runtime/test/generated/spec_V1_2/quantized_lstm.example.cpp

// Generated from quantized_lstm.mod.py
// DO NOT EDIT
// clang-format off
#include "TestHarness.h"

using namespace test_helper;

namespace generated_tests::quantized_lstm {

const TestModel& get_test_model() {
    static TestModel model = {
        .expectedMultinomialDistributionTolerance = 0,
        .inputIndexes = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14},
        .isRelaxed = false,
        .operands = {{
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({166, 179, 50, 150}),
                .dimensions = {2, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.0078125f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 128
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({146, 250, 235, 171, 10, 218, 171, 108}),
                .dimensions = {4, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({24, 50, 132, 179, 158, 110, 3, 169}),
                .dimensions = {4, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({133, 34, 29, 49, 206, 109, 54, 183}),
                .dimensions = {4, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({195, 187, 11, 99, 109, 10, 218, 48}),
                .dimensions = {4, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({254, 206, 77, 168, 71, 20, 215, 6, 223, 7, 118, 225, 59, 130, 174, 26}),
                .dimensions = {4, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({137, 240, 103, 52, 68, 51, 237, 112, 0, 220, 89, 23, 69, 4, 207, 253}),
                .dimensions = {4, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({172, 60, 205, 65, 14, 0, 140, 168, 240, 223, 133, 56, 142, 64, 246, 216}),
                .dimensions = {4, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({106, 214, 67, 23, 59, 158, 45, 3, 119, 132, 49, 205, 129, 218, 11, 98}),
                .dimensions = {4, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({-7876, 13488, -726, 32839}),
                .dimensions = {4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 3.1876640625e-05f,
                .type = TestOperandType::TENSOR_INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({9206, -46884, -11693, -38724}),
                .dimensions = {4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 3.1876640625e-05f,
                .type = TestOperandType::TENSOR_INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({39481, 48624, 48976, -21419}),
                .dimensions = {4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 3.1876640625e-05f,
                .type = TestOperandType::TENSOR_INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({-58999, -17050, -41852, -40538}),
                .dimensions = {4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 3.1876640625e-05f,
                .type = TestOperandType::TENSOR_INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int16_t>({876, 1034, 955, -909, 761, 1029, 796, -1036}),
                .dimensions = {2, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00048828125f,
                .type = TestOperandType::TENSOR_QUANT16_SYMM,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({136, 150, 140, 115, 135, 152, 138, 112}),
                .dimensions = {2, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.0078125f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 128
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int16_t>({1485, 1177, 1373, -1023, 1019, 1355, 1097, -1235}),
                .dimensions = {2, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_OUTPUT,
                .numberOfConsumers = 0,
                .scale = 0.00048828125f,
                .type = TestOperandType::TENSOR_QUANT16_SYMM,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({140, 151, 146, 112, 136, 156, 142, 112}),
                .dimensions = {2, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_OUTPUT,
                .numberOfConsumers = 0,
                .scale = 0.0078125f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 128
            }},
        .operations = {{
                .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14},
                .outputs = {15, 16},
                .type = TestOperationType::QUANTIZED_16BIT_LSTM
            }},
        .outputIndexes = {15, 16}
    };
    return model;
}

}  // namespace generated_tests::quantized_lstm

namespace generated_tests::quantized_lstm {

const TestModel& get_test_model_all_inputs_as_internal() {
    static TestModel model = {
        .expectedMultinomialDistributionTolerance = 0,
        .inputIndexes = {9, 10, 11, 12, 13, 17, 20, 23, 26, 29, 32, 35, 38, 41, 44},
        .isRelaxed = false,
        .operands = {{
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({}),
                .dimensions = {2, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                .numberOfConsumers = 1,
                .scale = 0.0078125f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 128
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({}),
                .dimensions = {4, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({}),
                .dimensions = {4, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({}),
                .dimensions = {4, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({}),
                .dimensions = {4, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({}),
                .dimensions = {4, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({}),
                .dimensions = {4, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({}),
                .dimensions = {4, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({}),
                .dimensions = {4, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({-7876, 13488, -726, 32839}),
                .dimensions = {4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 3.1876640625e-05f,
                .type = TestOperandType::TENSOR_INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({9206, -46884, -11693, -38724}),
                .dimensions = {4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 3.1876640625e-05f,
                .type = TestOperandType::TENSOR_INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({39481, 48624, 48976, -21419}),
                .dimensions = {4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 3.1876640625e-05f,
                .type = TestOperandType::TENSOR_INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({-58999, -17050, -41852, -40538}),
                .dimensions = {4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 3.1876640625e-05f,
                .type = TestOperandType::TENSOR_INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int16_t>({876, 1034, 955, -909, 761, 1029, 796, -1036}),
                .dimensions = {2, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00048828125f,
                .type = TestOperandType::TENSOR_QUANT16_SYMM,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({}),
                .dimensions = {2, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                .numberOfConsumers = 1,
                .scale = 0.0078125f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 128
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int16_t>({1485, 1177, 1373, -1023, 1019, 1355, 1097, -1235}),
                .dimensions = {2, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_OUTPUT,
                .numberOfConsumers = 0,
                .scale = 0.00048828125f,
                .type = TestOperandType::TENSOR_QUANT16_SYMM,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({140, 151, 146, 112, 136, 156, 142, 112}),
                .dimensions = {2, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_OUTPUT,
                .numberOfConsumers = 0,
                .scale = 0.0078125f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 128
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({166, 179, 50, 150}),
                .dimensions = {2, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.0078125f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 128
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({128}),
                .dimensions = {1},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.0078125f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 128
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({0}),
                .dimensions = {},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.0f,
                .type = TestOperandType::INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({146, 250, 235, 171, 10, 218, 171, 108}),
                .dimensions = {4, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({100}),
                .dimensions = {1},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({0}),
                .dimensions = {},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.0f,
                .type = TestOperandType::INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({24, 50, 132, 179, 158, 110, 3, 169}),
                .dimensions = {4, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({100}),
                .dimensions = {1},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({0}),
                .dimensions = {},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.0f,
                .type = TestOperandType::INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({133, 34, 29, 49, 206, 109, 54, 183}),
                .dimensions = {4, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({100}),
                .dimensions = {1},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({0}),
                .dimensions = {},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.0f,
                .type = TestOperandType::INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({195, 187, 11, 99, 109, 10, 218, 48}),
                .dimensions = {4, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({100}),
                .dimensions = {1},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({0}),
                .dimensions = {},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.0f,
                .type = TestOperandType::INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({254, 206, 77, 168, 71, 20, 215, 6, 223, 7, 118, 225, 59, 130, 174, 26}),
                .dimensions = {4, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({100}),
                .dimensions = {1},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({0}),
                .dimensions = {},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.0f,
                .type = TestOperandType::INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({137, 240, 103, 52, 68, 51, 237, 112, 0, 220, 89, 23, 69, 4, 207, 253}),
                .dimensions = {4, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({100}),
                .dimensions = {1},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({0}),
                .dimensions = {},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.0f,
                .type = TestOperandType::INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({172, 60, 205, 65, 14, 0, 140, 168, 240, 223, 133, 56, 142, 64, 246, 216}),
                .dimensions = {4, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({100}),
                .dimensions = {1},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({0}),
                .dimensions = {},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.0f,
                .type = TestOperandType::INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({106, 214, 67, 23, 59, 158, 45, 3, 119, 132, 49, 205, 129, 218, 11, 98}),
                .dimensions = {4, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({100}),
                .dimensions = {1},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({0}),
                .dimensions = {},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.0f,
                .type = TestOperandType::INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({136, 150, 140, 115, 135, 152, 138, 112}),
                .dimensions = {2, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.0078125f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 128
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({128}),
                .dimensions = {1},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.0078125f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 128
            }, {
                .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 = {17, 18, 19},
                .outputs = {0},
                .type = TestOperationType::ADD
            }, {
                .inputs = {20, 21, 22},
                .outputs = {1},
                .type = TestOperationType::ADD
            }, {
                .inputs = {23, 24, 25},
                .outputs = {2},
                .type = TestOperationType::ADD
            }, {
                .inputs = {26, 27, 28},
                .outputs = {3},
                .type = TestOperationType::ADD
            }, {
                .inputs = {29, 30, 31},
                .outputs = {4},
                .type = TestOperationType::ADD
            }, {
                .inputs = {32, 33, 34},
                .outputs = {5},
                .type = TestOperationType::ADD
            }, {
                .inputs = {35, 36, 37},
                .outputs = {6},
                .type = TestOperationType::ADD
            }, {
                .inputs = {38, 39, 40},
                .outputs = {7},
                .type = TestOperationType::ADD
            }, {
                .inputs = {41, 42, 43},
                .outputs = {8},
                .type = TestOperationType::ADD
            }, {
                .inputs = {44, 45, 46},
                .outputs = {14},
                .type = TestOperationType::ADD
            }, {
                .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14},
                .outputs = {15, 16},
                .type = TestOperationType::QUANTIZED_16BIT_LSTM
            }},
        .outputIndexes = {15, 16}
    };
    return model;
}

}  // namespace generated_tests::quantized_lstm

namespace generated_tests::quantized_lstm {

const TestModel& get_test_model_relaxed() {
    static TestModel model = {
        .expectedMultinomialDistributionTolerance = 0,
        .inputIndexes = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14},
        .isRelaxed = true,
        .operands = {{
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({166, 179, 50, 150}),
                .dimensions = {2, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.0078125f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 128
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({146, 250, 235, 171, 10, 218, 171, 108}),
                .dimensions = {4, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({24, 50, 132, 179, 158, 110, 3, 169}),
                .dimensions = {4, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({133, 34, 29, 49, 206, 109, 54, 183}),
                .dimensions = {4, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({195, 187, 11, 99, 109, 10, 218, 48}),
                .dimensions = {4, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({254, 206, 77, 168, 71, 20, 215, 6, 223, 7, 118, 225, 59, 130, 174, 26}),
                .dimensions = {4, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({137, 240, 103, 52, 68, 51, 237, 112, 0, 220, 89, 23, 69, 4, 207, 253}),
                .dimensions = {4, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({172, 60, 205, 65, 14, 0, 140, 168, 240, 223, 133, 56, 142, 64, 246, 216}),
                .dimensions = {4, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({106, 214, 67, 23, 59, 158, 45, 3, 119, 132, 49, 205, 129, 218, 11, 98}),
                .dimensions = {4, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({-7876, 13488, -726, 32839}),
                .dimensions = {4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 3.1876640625e-05f,
                .type = TestOperandType::TENSOR_INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({9206, -46884, -11693, -38724}),
                .dimensions = {4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 3.1876640625e-05f,
                .type = TestOperandType::TENSOR_INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({39481, 48624, 48976, -21419}),
                .dimensions = {4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 3.1876640625e-05f,
                .type = TestOperandType::TENSOR_INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({-58999, -17050, -41852, -40538}),
                .dimensions = {4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 3.1876640625e-05f,
                .type = TestOperandType::TENSOR_INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int16_t>({876, 1034, 955, -909, 761, 1029, 796, -1036}),
                .dimensions = {2, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00048828125f,
                .type = TestOperandType::TENSOR_QUANT16_SYMM,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({136, 150, 140, 115, 135, 152, 138, 112}),
                .dimensions = {2, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.0078125f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 128
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int16_t>({1485, 1177, 1373, -1023, 1019, 1355, 1097, -1235}),
                .dimensions = {2, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_OUTPUT,
                .numberOfConsumers = 0,
                .scale = 0.00048828125f,
                .type = TestOperandType::TENSOR_QUANT16_SYMM,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({140, 151, 146, 112, 136, 156, 142, 112}),
                .dimensions = {2, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_OUTPUT,
                .numberOfConsumers = 0,
                .scale = 0.0078125f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 128
            }},
        .operations = {{
                .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14},
                .outputs = {15, 16},
                .type = TestOperationType::QUANTIZED_16BIT_LSTM
            }},
        .outputIndexes = {15, 16}
    };
    return model;
}

}  // namespace generated_tests::quantized_lstm

namespace generated_tests::quantized_lstm {

const TestModel& get_test_model_relaxed_all_inputs_as_internal() {
    static TestModel model = {
        .expectedMultinomialDistributionTolerance = 0,
        .inputIndexes = {9, 10, 11, 12, 13, 17, 20, 23, 26, 29, 32, 35, 38, 41, 44},
        .isRelaxed = true,
        .operands = {{
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({}),
                .dimensions = {2, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                .numberOfConsumers = 1,
                .scale = 0.0078125f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 128
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({}),
                .dimensions = {4, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({}),
                .dimensions = {4, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({}),
                .dimensions = {4, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({}),
                .dimensions = {4, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({}),
                .dimensions = {4, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({}),
                .dimensions = {4, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({}),
                .dimensions = {4, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({}),
                .dimensions = {4, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({-7876, 13488, -726, 32839}),
                .dimensions = {4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 3.1876640625e-05f,
                .type = TestOperandType::TENSOR_INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({9206, -46884, -11693, -38724}),
                .dimensions = {4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 3.1876640625e-05f,
                .type = TestOperandType::TENSOR_INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({39481, 48624, 48976, -21419}),
                .dimensions = {4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 3.1876640625e-05f,
                .type = TestOperandType::TENSOR_INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({-58999, -17050, -41852, -40538}),
                .dimensions = {4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 3.1876640625e-05f,
                .type = TestOperandType::TENSOR_INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int16_t>({876, 1034, 955, -909, 761, 1029, 796, -1036}),
                .dimensions = {2, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00048828125f,
                .type = TestOperandType::TENSOR_QUANT16_SYMM,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({}),
                .dimensions = {2, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                .numberOfConsumers = 1,
                .scale = 0.0078125f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 128
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int16_t>({1485, 1177, 1373, -1023, 1019, 1355, 1097, -1235}),
                .dimensions = {2, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_OUTPUT,
                .numberOfConsumers = 0,
                .scale = 0.00048828125f,
                .type = TestOperandType::TENSOR_QUANT16_SYMM,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({140, 151, 146, 112, 136, 156, 142, 112}),
                .dimensions = {2, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_OUTPUT,
                .numberOfConsumers = 0,
                .scale = 0.0078125f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 128
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({166, 179, 50, 150}),
                .dimensions = {2, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.0078125f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 128
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({128}),
                .dimensions = {1},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.0078125f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 128
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({0}),
                .dimensions = {},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.0f,
                .type = TestOperandType::INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({146, 250, 235, 171, 10, 218, 171, 108}),
                .dimensions = {4, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({100}),
                .dimensions = {1},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({0}),
                .dimensions = {},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.0f,
                .type = TestOperandType::INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({24, 50, 132, 179, 158, 110, 3, 169}),
                .dimensions = {4, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({100}),
                .dimensions = {1},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({0}),
                .dimensions = {},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.0f,
                .type = TestOperandType::INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({133, 34, 29, 49, 206, 109, 54, 183}),
                .dimensions = {4, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({100}),
                .dimensions = {1},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({0}),
                .dimensions = {},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.0f,
                .type = TestOperandType::INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({195, 187, 11, 99, 109, 10, 218, 48}),
                .dimensions = {4, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({100}),
                .dimensions = {1},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({0}),
                .dimensions = {},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.0f,
                .type = TestOperandType::INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({254, 206, 77, 168, 71, 20, 215, 6, 223, 7, 118, 225, 59, 130, 174, 26}),
                .dimensions = {4, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({100}),
                .dimensions = {1},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({0}),
                .dimensions = {},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.0f,
                .type = TestOperandType::INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({137, 240, 103, 52, 68, 51, 237, 112, 0, 220, 89, 23, 69, 4, 207, 253}),
                .dimensions = {4, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({100}),
                .dimensions = {1},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({0}),
                .dimensions = {},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.0f,
                .type = TestOperandType::INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({172, 60, 205, 65, 14, 0, 140, 168, 240, 223, 133, 56, 142, 64, 246, 216}),
                .dimensions = {4, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({100}),
                .dimensions = {1},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({0}),
                .dimensions = {},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.0f,
                .type = TestOperandType::INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({106, 214, 67, 23, 59, 158, 45, 3, 119, 132, 49, 205, 129, 218, 11, 98}),
                .dimensions = {4, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({100}),
                .dimensions = {1},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({0}),
                .dimensions = {},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.0f,
                .type = TestOperandType::INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({136, 150, 140, 115, 135, 152, 138, 112}),
                .dimensions = {2, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.0078125f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 128
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({128}),
                .dimensions = {1},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.0078125f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 128
            }, {
                .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 = {17, 18, 19},
                .outputs = {0},
                .type = TestOperationType::ADD
            }, {
                .inputs = {20, 21, 22},
                .outputs = {1},
                .type = TestOperationType::ADD
            }, {
                .inputs = {23, 24, 25},
                .outputs = {2},
                .type = TestOperationType::ADD
            }, {
                .inputs = {26, 27, 28},
                .outputs = {3},
                .type = TestOperationType::ADD
            }, {
                .inputs = {29, 30, 31},
                .outputs = {4},
                .type = TestOperationType::ADD
            }, {
                .inputs = {32, 33, 34},
                .outputs = {5},
                .type = TestOperationType::ADD
            }, {
                .inputs = {35, 36, 37},
                .outputs = {6},
                .type = TestOperationType::ADD
            }, {
                .inputs = {38, 39, 40},
                .outputs = {7},
                .type = TestOperationType::ADD
            }, {
                .inputs = {41, 42, 43},
                .outputs = {8},
                .type = TestOperationType::ADD
            }, {
                .inputs = {44, 45, 46},
                .outputs = {14},
                .type = TestOperationType::ADD
            }, {
                .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14},
                .outputs = {15, 16},
                .type = TestOperationType::QUANTIZED_16BIT_LSTM
            }},
        .outputIndexes = {15, 16}
    };
    return model;
}

}  // namespace generated_tests::quantized_lstm

namespace generated_tests::quantized_lstm {

const TestModel& get_test_model_constant_weights() {
    static TestModel model = {
        .expectedMultinomialDistributionTolerance = 0,
        .inputIndexes = {0, 13, 14},
        .isRelaxed = false,
        .operands = {{
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({166, 179}),
                .dimensions = {1, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.0078125f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 128
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({146, 250, 235, 171, 10, 218, 171, 108}),
                .dimensions = {4, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({24, 50, 132, 179, 158, 110, 3, 169}),
                .dimensions = {4, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({133, 34, 29, 49, 206, 109, 54, 183}),
                .dimensions = {4, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({195, 187, 11, 99, 109, 10, 218, 48}),
                .dimensions = {4, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({254, 206, 77, 168, 71, 20, 215, 6, 223, 7, 118, 225, 59, 130, 174, 26}),
                .dimensions = {4, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({137, 240, 103, 52, 68, 51, 237, 112, 0, 220, 89, 23, 69, 4, 207, 253}),
                .dimensions = {4, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({172, 60, 205, 65, 14, 0, 140, 168, 240, 223, 133, 56, 142, 64, 246, 216}),
                .dimensions = {4, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({106, 214, 67, 23, 59, 158, 45, 3, 119, 132, 49, 205, 129, 218, 11, 98}),
                .dimensions = {4, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({-7876, 13488, -726, 32839}),
                .dimensions = {4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 3.1876640625e-05f,
                .type = TestOperandType::TENSOR_INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({9206, -46884, -11693, -38724}),
                .dimensions = {4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 3.1876640625e-05f,
                .type = TestOperandType::TENSOR_INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({39481, 48624, 48976, -21419}),
                .dimensions = {4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 3.1876640625e-05f,
                .type = TestOperandType::TENSOR_INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({-58999, -17050, -41852, -40538}),
                .dimensions = {4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 3.1876640625e-05f,
                .type = TestOperandType::TENSOR_INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int16_t>({876, 1034, 955, -909}),
                .dimensions = {1, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00048828125f,
                .type = TestOperandType::TENSOR_QUANT16_SYMM,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({136, 150, 140, 115}),
                .dimensions = {1, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.0078125f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 128
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int16_t>({1485, 1177, 1373, -1023}),
                .dimensions = {1, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_OUTPUT,
                .numberOfConsumers = 0,
                .scale = 0.00048828125f,
                .type = TestOperandType::TENSOR_QUANT16_SYMM,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({140, 151, 146, 112}),
                .dimensions = {1, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_OUTPUT,
                .numberOfConsumers = 0,
                .scale = 0.0078125f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 128
            }},
        .operations = {{
                .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14},
                .outputs = {15, 16},
                .type = TestOperationType::QUANTIZED_16BIT_LSTM
            }},
        .outputIndexes = {15, 16}
    };
    return model;
}

}  // namespace generated_tests::quantized_lstm

namespace generated_tests::quantized_lstm {

const TestModel& get_test_model_constant_weights_all_inputs_as_internal() {
    static TestModel model = {
        .expectedMultinomialDistributionTolerance = 0,
        .inputIndexes = {13, 17, 20},
        .isRelaxed = false,
        .operands = {{
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({}),
                .dimensions = {1, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                .numberOfConsumers = 1,
                .scale = 0.0078125f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 128
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({146, 250, 235, 171, 10, 218, 171, 108}),
                .dimensions = {4, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({24, 50, 132, 179, 158, 110, 3, 169}),
                .dimensions = {4, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({133, 34, 29, 49, 206, 109, 54, 183}),
                .dimensions = {4, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({195, 187, 11, 99, 109, 10, 218, 48}),
                .dimensions = {4, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({254, 206, 77, 168, 71, 20, 215, 6, 223, 7, 118, 225, 59, 130, 174, 26}),
                .dimensions = {4, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({137, 240, 103, 52, 68, 51, 237, 112, 0, 220, 89, 23, 69, 4, 207, 253}),
                .dimensions = {4, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({172, 60, 205, 65, 14, 0, 140, 168, 240, 223, 133, 56, 142, 64, 246, 216}),
                .dimensions = {4, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({106, 214, 67, 23, 59, 158, 45, 3, 119, 132, 49, 205, 129, 218, 11, 98}),
                .dimensions = {4, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({-7876, 13488, -726, 32839}),
                .dimensions = {4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 3.1876640625e-05f,
                .type = TestOperandType::TENSOR_INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({9206, -46884, -11693, -38724}),
                .dimensions = {4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 3.1876640625e-05f,
                .type = TestOperandType::TENSOR_INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({39481, 48624, 48976, -21419}),
                .dimensions = {4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 3.1876640625e-05f,
                .type = TestOperandType::TENSOR_INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({-58999, -17050, -41852, -40538}),
                .dimensions = {4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 3.1876640625e-05f,
                .type = TestOperandType::TENSOR_INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int16_t>({876, 1034, 955, -909}),
                .dimensions = {1, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00048828125f,
                .type = TestOperandType::TENSOR_QUANT16_SYMM,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({}),
                .dimensions = {1, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                .numberOfConsumers = 1,
                .scale = 0.0078125f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 128
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int16_t>({1485, 1177, 1373, -1023}),
                .dimensions = {1, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_OUTPUT,
                .numberOfConsumers = 0,
                .scale = 0.00048828125f,
                .type = TestOperandType::TENSOR_QUANT16_SYMM,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({140, 151, 146, 112}),
                .dimensions = {1, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_OUTPUT,
                .numberOfConsumers = 0,
                .scale = 0.0078125f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 128
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({166, 179}),
                .dimensions = {1, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.0078125f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 128
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({128}),
                .dimensions = {1},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.0078125f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 128
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({0}),
                .dimensions = {},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.0f,
                .type = TestOperandType::INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({136, 150, 140, 115}),
                .dimensions = {1, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.0078125f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 128
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({128}),
                .dimensions = {1},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.0078125f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 128
            }, {
                .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 = {17, 18, 19},
                .outputs = {0},
                .type = TestOperationType::ADD
            }, {
                .inputs = {20, 21, 22},
                .outputs = {14},
                .type = TestOperationType::ADD
            }, {
                .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14},
                .outputs = {15, 16},
                .type = TestOperationType::QUANTIZED_16BIT_LSTM
            }},
        .outputIndexes = {15, 16}
    };
    return model;
}

}  // namespace generated_tests::quantized_lstm

namespace generated_tests::quantized_lstm {

const TestModel& get_test_model_constant_weights_all_tensors_as_inputs() {
    static TestModel model = {
        .expectedMultinomialDistributionTolerance = 0,
        .inputIndexes = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14},
        .isRelaxed = false,
        .operands = {{
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({166, 179}),
                .dimensions = {1, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.0078125f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 128
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({146, 250, 235, 171, 10, 218, 171, 108}),
                .dimensions = {4, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({24, 50, 132, 179, 158, 110, 3, 169}),
                .dimensions = {4, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({133, 34, 29, 49, 206, 109, 54, 183}),
                .dimensions = {4, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({195, 187, 11, 99, 109, 10, 218, 48}),
                .dimensions = {4, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({254, 206, 77, 168, 71, 20, 215, 6, 223, 7, 118, 225, 59, 130, 174, 26}),
                .dimensions = {4, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({137, 240, 103, 52, 68, 51, 237, 112, 0, 220, 89, 23, 69, 4, 207, 253}),
                .dimensions = {4, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({172, 60, 205, 65, 14, 0, 140, 168, 240, 223, 133, 56, 142, 64, 246, 216}),
                .dimensions = {4, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({106, 214, 67, 23, 59, 158, 45, 3, 119, 132, 49, 205, 129, 218, 11, 98}),
                .dimensions = {4, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({-7876, 13488, -726, 32839}),
                .dimensions = {4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 3.1876640625e-05f,
                .type = TestOperandType::TENSOR_INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({9206, -46884, -11693, -38724}),
                .dimensions = {4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 3.1876640625e-05f,
                .type = TestOperandType::TENSOR_INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({39481, 48624, 48976, -21419}),
                .dimensions = {4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 3.1876640625e-05f,
                .type = TestOperandType::TENSOR_INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({-58999, -17050, -41852, -40538}),
                .dimensions = {4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 3.1876640625e-05f,
                .type = TestOperandType::TENSOR_INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int16_t>({876, 1034, 955, -909}),
                .dimensions = {1, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00048828125f,
                .type = TestOperandType::TENSOR_QUANT16_SYMM,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({136, 150, 140, 115}),
                .dimensions = {1, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.0078125f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 128
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int16_t>({1485, 1177, 1373, -1023}),
                .dimensions = {1, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_OUTPUT,
                .numberOfConsumers = 0,
                .scale = 0.00048828125f,
                .type = TestOperandType::TENSOR_QUANT16_SYMM,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({140, 151, 146, 112}),
                .dimensions = {1, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_OUTPUT,
                .numberOfConsumers = 0,
                .scale = 0.0078125f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 128
            }},
        .operations = {{
                .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14},
                .outputs = {15, 16},
                .type = TestOperationType::QUANTIZED_16BIT_LSTM
            }},
        .outputIndexes = {15, 16}
    };
    return model;
}

}  // namespace generated_tests::quantized_lstm

namespace generated_tests::quantized_lstm {

const TestModel& get_test_model_constant_weights_all_tensors_as_inputs_all_inputs_as_internal() {
    static TestModel model = {
        .expectedMultinomialDistributionTolerance = 0,
        .inputIndexes = {9, 10, 11, 12, 13, 17, 20, 23, 26, 29, 32, 35, 38, 41, 44},
        .isRelaxed = false,
        .operands = {{
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({}),
                .dimensions = {1, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                .numberOfConsumers = 1,
                .scale = 0.0078125f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 128
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({}),
                .dimensions = {4, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({}),
                .dimensions = {4, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({}),
                .dimensions = {4, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({}),
                .dimensions = {4, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({}),
                .dimensions = {4, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({}),
                .dimensions = {4, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({}),
                .dimensions = {4, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({}),
                .dimensions = {4, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({-7876, 13488, -726, 32839}),
                .dimensions = {4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 3.1876640625e-05f,
                .type = TestOperandType::TENSOR_INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({9206, -46884, -11693, -38724}),
                .dimensions = {4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 3.1876640625e-05f,
                .type = TestOperandType::TENSOR_INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({39481, 48624, 48976, -21419}),
                .dimensions = {4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 3.1876640625e-05f,
                .type = TestOperandType::TENSOR_INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({-58999, -17050, -41852, -40538}),
                .dimensions = {4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 3.1876640625e-05f,
                .type = TestOperandType::TENSOR_INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int16_t>({876, 1034, 955, -909}),
                .dimensions = {1, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00048828125f,
                .type = TestOperandType::TENSOR_QUANT16_SYMM,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({}),
                .dimensions = {1, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                .numberOfConsumers = 1,
                .scale = 0.0078125f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 128
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int16_t>({1485, 1177, 1373, -1023}),
                .dimensions = {1, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_OUTPUT,
                .numberOfConsumers = 0,
                .scale = 0.00048828125f,
                .type = TestOperandType::TENSOR_QUANT16_SYMM,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({140, 151, 146, 112}),
                .dimensions = {1, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_OUTPUT,
                .numberOfConsumers = 0,
                .scale = 0.0078125f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 128
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({166, 179}),
                .dimensions = {1, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.0078125f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 128
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({128}),
                .dimensions = {1},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.0078125f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 128
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({0}),
                .dimensions = {},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.0f,
                .type = TestOperandType::INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({146, 250, 235, 171, 10, 218, 171, 108}),
                .dimensions = {4, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({100}),
                .dimensions = {1},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({0}),
                .dimensions = {},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.0f,
                .type = TestOperandType::INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({24, 50, 132, 179, 158, 110, 3, 169}),
                .dimensions = {4, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({100}),
                .dimensions = {1},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({0}),
                .dimensions = {},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.0f,
                .type = TestOperandType::INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({133, 34, 29, 49, 206, 109, 54, 183}),
                .dimensions = {4, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({100}),
                .dimensions = {1},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({0}),
                .dimensions = {},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.0f,
                .type = TestOperandType::INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({195, 187, 11, 99, 109, 10, 218, 48}),
                .dimensions = {4, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({100}),
                .dimensions = {1},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({0}),
                .dimensions = {},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.0f,
                .type = TestOperandType::INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({254, 206, 77, 168, 71, 20, 215, 6, 223, 7, 118, 225, 59, 130, 174, 26}),
                .dimensions = {4, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({100}),
                .dimensions = {1},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({0}),
                .dimensions = {},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.0f,
                .type = TestOperandType::INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({137, 240, 103, 52, 68, 51, 237, 112, 0, 220, 89, 23, 69, 4, 207, 253}),
                .dimensions = {4, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({100}),
                .dimensions = {1},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({0}),
                .dimensions = {},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.0f,
                .type = TestOperandType::INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({172, 60, 205, 65, 14, 0, 140, 168, 240, 223, 133, 56, 142, 64, 246, 216}),
                .dimensions = {4, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({100}),
                .dimensions = {1},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({0}),
                .dimensions = {},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.0f,
                .type = TestOperandType::INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({106, 214, 67, 23, 59, 158, 45, 3, 119, 132, 49, 205, 129, 218, 11, 98}),
                .dimensions = {4, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({100}),
                .dimensions = {1},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({0}),
                .dimensions = {},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.0f,
                .type = TestOperandType::INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({136, 150, 140, 115}),
                .dimensions = {1, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.0078125f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 128
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({128}),
                .dimensions = {1},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.0078125f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 128
            }, {
                .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 = {17, 18, 19},
                .outputs = {0},
                .type = TestOperationType::ADD
            }, {
                .inputs = {20, 21, 22},
                .outputs = {1},
                .type = TestOperationType::ADD
            }, {
                .inputs = {23, 24, 25},
                .outputs = {2},
                .type = TestOperationType::ADD
            }, {
                .inputs = {26, 27, 28},
                .outputs = {3},
                .type = TestOperationType::ADD
            }, {
                .inputs = {29, 30, 31},
                .outputs = {4},
                .type = TestOperationType::ADD
            }, {
                .inputs = {32, 33, 34},
                .outputs = {5},
                .type = TestOperationType::ADD
            }, {
                .inputs = {35, 36, 37},
                .outputs = {6},
                .type = TestOperationType::ADD
            }, {
                .inputs = {38, 39, 40},
                .outputs = {7},
                .type = TestOperationType::ADD
            }, {
                .inputs = {41, 42, 43},
                .outputs = {8},
                .type = TestOperationType::ADD
            }, {
                .inputs = {44, 45, 46},
                .outputs = {14},
                .type = TestOperationType::ADD
            }, {
                .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14},
                .outputs = {15, 16},
                .type = TestOperationType::QUANTIZED_16BIT_LSTM
            }},
        .outputIndexes = {15, 16}
    };
    return model;
}

}  // namespace generated_tests::quantized_lstm

namespace generated_tests::quantized_lstm {

const TestModel& get_test_model_constant_weights_relaxed() {
    static TestModel model = {
        .expectedMultinomialDistributionTolerance = 0,
        .inputIndexes = {0, 13, 14},
        .isRelaxed = true,
        .operands = {{
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({166, 179}),
                .dimensions = {1, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.0078125f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 128
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({146, 250, 235, 171, 10, 218, 171, 108}),
                .dimensions = {4, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({24, 50, 132, 179, 158, 110, 3, 169}),
                .dimensions = {4, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({133, 34, 29, 49, 206, 109, 54, 183}),
                .dimensions = {4, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({195, 187, 11, 99, 109, 10, 218, 48}),
                .dimensions = {4, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({254, 206, 77, 168, 71, 20, 215, 6, 223, 7, 118, 225, 59, 130, 174, 26}),
                .dimensions = {4, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({137, 240, 103, 52, 68, 51, 237, 112, 0, 220, 89, 23, 69, 4, 207, 253}),
                .dimensions = {4, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({172, 60, 205, 65, 14, 0, 140, 168, 240, 223, 133, 56, 142, 64, 246, 216}),
                .dimensions = {4, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({106, 214, 67, 23, 59, 158, 45, 3, 119, 132, 49, 205, 129, 218, 11, 98}),
                .dimensions = {4, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({-7876, 13488, -726, 32839}),
                .dimensions = {4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 3.1876640625e-05f,
                .type = TestOperandType::TENSOR_INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({9206, -46884, -11693, -38724}),
                .dimensions = {4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 3.1876640625e-05f,
                .type = TestOperandType::TENSOR_INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({39481, 48624, 48976, -21419}),
                .dimensions = {4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 3.1876640625e-05f,
                .type = TestOperandType::TENSOR_INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({-58999, -17050, -41852, -40538}),
                .dimensions = {4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 3.1876640625e-05f,
                .type = TestOperandType::TENSOR_INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int16_t>({876, 1034, 955, -909}),
                .dimensions = {1, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00048828125f,
                .type = TestOperandType::TENSOR_QUANT16_SYMM,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({136, 150, 140, 115}),
                .dimensions = {1, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.0078125f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 128
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int16_t>({1485, 1177, 1373, -1023}),
                .dimensions = {1, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_OUTPUT,
                .numberOfConsumers = 0,
                .scale = 0.00048828125f,
                .type = TestOperandType::TENSOR_QUANT16_SYMM,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({140, 151, 146, 112}),
                .dimensions = {1, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_OUTPUT,
                .numberOfConsumers = 0,
                .scale = 0.0078125f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 128
            }},
        .operations = {{
                .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14},
                .outputs = {15, 16},
                .type = TestOperationType::QUANTIZED_16BIT_LSTM
            }},
        .outputIndexes = {15, 16}
    };
    return model;
}

}  // namespace generated_tests::quantized_lstm

namespace generated_tests::quantized_lstm {

const TestModel& get_test_model_constant_weights_relaxed_all_inputs_as_internal() {
    static TestModel model = {
        .expectedMultinomialDistributionTolerance = 0,
        .inputIndexes = {13, 17, 20},
        .isRelaxed = true,
        .operands = {{
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({}),
                .dimensions = {1, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                .numberOfConsumers = 1,
                .scale = 0.0078125f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 128
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({146, 250, 235, 171, 10, 218, 171, 108}),
                .dimensions = {4, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({24, 50, 132, 179, 158, 110, 3, 169}),
                .dimensions = {4, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({133, 34, 29, 49, 206, 109, 54, 183}),
                .dimensions = {4, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({195, 187, 11, 99, 109, 10, 218, 48}),
                .dimensions = {4, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({254, 206, 77, 168, 71, 20, 215, 6, 223, 7, 118, 225, 59, 130, 174, 26}),
                .dimensions = {4, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({137, 240, 103, 52, 68, 51, 237, 112, 0, 220, 89, 23, 69, 4, 207, 253}),
                .dimensions = {4, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({172, 60, 205, 65, 14, 0, 140, 168, 240, 223, 133, 56, 142, 64, 246, 216}),
                .dimensions = {4, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({106, 214, 67, 23, 59, 158, 45, 3, 119, 132, 49, 205, 129, 218, 11, 98}),
                .dimensions = {4, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({-7876, 13488, -726, 32839}),
                .dimensions = {4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 3.1876640625e-05f,
                .type = TestOperandType::TENSOR_INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({9206, -46884, -11693, -38724}),
                .dimensions = {4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 3.1876640625e-05f,
                .type = TestOperandType::TENSOR_INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({39481, 48624, 48976, -21419}),
                .dimensions = {4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 3.1876640625e-05f,
                .type = TestOperandType::TENSOR_INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({-58999, -17050, -41852, -40538}),
                .dimensions = {4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 3.1876640625e-05f,
                .type = TestOperandType::TENSOR_INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int16_t>({876, 1034, 955, -909}),
                .dimensions = {1, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00048828125f,
                .type = TestOperandType::TENSOR_QUANT16_SYMM,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({}),
                .dimensions = {1, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                .numberOfConsumers = 1,
                .scale = 0.0078125f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 128
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int16_t>({1485, 1177, 1373, -1023}),
                .dimensions = {1, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_OUTPUT,
                .numberOfConsumers = 0,
                .scale = 0.00048828125f,
                .type = TestOperandType::TENSOR_QUANT16_SYMM,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({140, 151, 146, 112}),
                .dimensions = {1, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_OUTPUT,
                .numberOfConsumers = 0,
                .scale = 0.0078125f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 128
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({166, 179}),
                .dimensions = {1, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.0078125f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 128
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({128}),
                .dimensions = {1},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.0078125f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 128
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({0}),
                .dimensions = {},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.0f,
                .type = TestOperandType::INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({136, 150, 140, 115}),
                .dimensions = {1, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.0078125f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 128
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({128}),
                .dimensions = {1},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.0078125f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 128
            }, {
                .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 = {17, 18, 19},
                .outputs = {0},
                .type = TestOperationType::ADD
            }, {
                .inputs = {20, 21, 22},
                .outputs = {14},
                .type = TestOperationType::ADD
            }, {
                .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14},
                .outputs = {15, 16},
                .type = TestOperationType::QUANTIZED_16BIT_LSTM
            }},
        .outputIndexes = {15, 16}
    };
    return model;
}

}  // namespace generated_tests::quantized_lstm

namespace generated_tests::quantized_lstm {

const TestModel& get_test_model_constant_weights_relaxed_all_tensors_as_inputs() {
    static TestModel model = {
        .expectedMultinomialDistributionTolerance = 0,
        .inputIndexes = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14},
        .isRelaxed = true,
        .operands = {{
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({166, 179}),
                .dimensions = {1, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.0078125f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 128
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({146, 250, 235, 171, 10, 218, 171, 108}),
                .dimensions = {4, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({24, 50, 132, 179, 158, 110, 3, 169}),
                .dimensions = {4, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({133, 34, 29, 49, 206, 109, 54, 183}),
                .dimensions = {4, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({195, 187, 11, 99, 109, 10, 218, 48}),
                .dimensions = {4, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({254, 206, 77, 168, 71, 20, 215, 6, 223, 7, 118, 225, 59, 130, 174, 26}),
                .dimensions = {4, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({137, 240, 103, 52, 68, 51, 237, 112, 0, 220, 89, 23, 69, 4, 207, 253}),
                .dimensions = {4, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({172, 60, 205, 65, 14, 0, 140, 168, 240, 223, 133, 56, 142, 64, 246, 216}),
                .dimensions = {4, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({106, 214, 67, 23, 59, 158, 45, 3, 119, 132, 49, 205, 129, 218, 11, 98}),
                .dimensions = {4, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({-7876, 13488, -726, 32839}),
                .dimensions = {4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 3.1876640625e-05f,
                .type = TestOperandType::TENSOR_INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({9206, -46884, -11693, -38724}),
                .dimensions = {4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 3.1876640625e-05f,
                .type = TestOperandType::TENSOR_INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({39481, 48624, 48976, -21419}),
                .dimensions = {4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 3.1876640625e-05f,
                .type = TestOperandType::TENSOR_INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({-58999, -17050, -41852, -40538}),
                .dimensions = {4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 3.1876640625e-05f,
                .type = TestOperandType::TENSOR_INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int16_t>({876, 1034, 955, -909}),
                .dimensions = {1, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00048828125f,
                .type = TestOperandType::TENSOR_QUANT16_SYMM,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({136, 150, 140, 115}),
                .dimensions = {1, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.0078125f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 128
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int16_t>({1485, 1177, 1373, -1023}),
                .dimensions = {1, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_OUTPUT,
                .numberOfConsumers = 0,
                .scale = 0.00048828125f,
                .type = TestOperandType::TENSOR_QUANT16_SYMM,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({140, 151, 146, 112}),
                .dimensions = {1, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_OUTPUT,
                .numberOfConsumers = 0,
                .scale = 0.0078125f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 128
            }},
        .operations = {{
                .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14},
                .outputs = {15, 16},
                .type = TestOperationType::QUANTIZED_16BIT_LSTM
            }},
        .outputIndexes = {15, 16}
    };
    return model;
}

}  // namespace generated_tests::quantized_lstm

namespace generated_tests::quantized_lstm {

const TestModel& get_test_model_constant_weights_relaxed_all_tensors_as_inputs_all_inputs_as_internal() {
    static TestModel model = {
        .expectedMultinomialDistributionTolerance = 0,
        .inputIndexes = {9, 10, 11, 12, 13, 17, 20, 23, 26, 29, 32, 35, 38, 41, 44},
        .isRelaxed = true,
        .operands = {{
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({}),
                .dimensions = {1, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                .numberOfConsumers = 1,
                .scale = 0.0078125f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 128
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({}),
                .dimensions = {4, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({}),
                .dimensions = {4, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({}),
                .dimensions = {4, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({}),
                .dimensions = {4, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({}),
                .dimensions = {4, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({}),
                .dimensions = {4, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({}),
                .dimensions = {4, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({}),
                .dimensions = {4, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({-7876, 13488, -726, 32839}),
                .dimensions = {4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 3.1876640625e-05f,
                .type = TestOperandType::TENSOR_INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({9206, -46884, -11693, -38724}),
                .dimensions = {4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 3.1876640625e-05f,
                .type = TestOperandType::TENSOR_INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({39481, 48624, 48976, -21419}),
                .dimensions = {4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 3.1876640625e-05f,
                .type = TestOperandType::TENSOR_INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({-58999, -17050, -41852, -40538}),
                .dimensions = {4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 3.1876640625e-05f,
                .type = TestOperandType::TENSOR_INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int16_t>({876, 1034, 955, -909}),
                .dimensions = {1, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00048828125f,
                .type = TestOperandType::TENSOR_QUANT16_SYMM,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({}),
                .dimensions = {1, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                .numberOfConsumers = 1,
                .scale = 0.0078125f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 128
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int16_t>({1485, 1177, 1373, -1023}),
                .dimensions = {1, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_OUTPUT,
                .numberOfConsumers = 0,
                .scale = 0.00048828125f,
                .type = TestOperandType::TENSOR_QUANT16_SYMM,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({140, 151, 146, 112}),
                .dimensions = {1, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_OUTPUT,
                .numberOfConsumers = 0,
                .scale = 0.0078125f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 128
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({166, 179}),
                .dimensions = {1, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.0078125f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 128
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({128}),
                .dimensions = {1},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.0078125f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 128
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({0}),
                .dimensions = {},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.0f,
                .type = TestOperandType::INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({146, 250, 235, 171, 10, 218, 171, 108}),
                .dimensions = {4, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({100}),
                .dimensions = {1},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({0}),
                .dimensions = {},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.0f,
                .type = TestOperandType::INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({24, 50, 132, 179, 158, 110, 3, 169}),
                .dimensions = {4, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({100}),
                .dimensions = {1},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({0}),
                .dimensions = {},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.0f,
                .type = TestOperandType::INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({133, 34, 29, 49, 206, 109, 54, 183}),
                .dimensions = {4, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({100}),
                .dimensions = {1},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({0}),
                .dimensions = {},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.0f,
                .type = TestOperandType::INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({195, 187, 11, 99, 109, 10, 218, 48}),
                .dimensions = {4, 2},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({100}),
                .dimensions = {1},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({0}),
                .dimensions = {},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.0f,
                .type = TestOperandType::INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({254, 206, 77, 168, 71, 20, 215, 6, 223, 7, 118, 225, 59, 130, 174, 26}),
                .dimensions = {4, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({100}),
                .dimensions = {1},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({0}),
                .dimensions = {},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.0f,
                .type = TestOperandType::INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({137, 240, 103, 52, 68, 51, 237, 112, 0, 220, 89, 23, 69, 4, 207, 253}),
                .dimensions = {4, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({100}),
                .dimensions = {1},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({0}),
                .dimensions = {},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.0f,
                .type = TestOperandType::INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({172, 60, 205, 65, 14, 0, 140, 168, 240, 223, 133, 56, 142, 64, 246, 216}),
                .dimensions = {4, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({100}),
                .dimensions = {1},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({0}),
                .dimensions = {},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.0f,
                .type = TestOperandType::INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({106, 214, 67, 23, 59, 158, 45, 3, 119, 132, 49, 205, 129, 218, 11, 98}),
                .dimensions = {4, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({100}),
                .dimensions = {1},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.00408021f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 100
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<int32_t>({0}),
                .dimensions = {},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.0f,
                .type = TestOperandType::INT32,
                .zeroPoint = 0
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({136, 150, 140, 115}),
                .dimensions = {1, 4},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::MODEL_INPUT,
                .numberOfConsumers = 1,
                .scale = 0.0078125f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 128
            }, {
                .channelQuant = {},
                .data = TestBuffer::createFromVector<uint8_t>({128}),
                .dimensions = {1},
                .isIgnored = false,
                .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                .numberOfConsumers = 1,
                .scale = 0.0078125f,
                .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                .zeroPoint = 128
            }, {
                .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 = {17, 18, 19},
                .outputs = {0},
                .type = TestOperationType::ADD
            }, {
                .inputs = {20, 21, 22},
                .outputs = {1},
                .type = TestOperationType::ADD
            }, {
                .inputs = {23, 24, 25},
                .outputs = {2},
                .type = TestOperationType::ADD
            }, {
                .inputs = {26, 27, 28},
                .outputs = {3},
                .type = TestOperationType::ADD
            }, {
                .inputs = {29, 30, 31},
                .outputs = {4},
                .type = TestOperationType::ADD
            }, {
                .inputs = {32, 33, 34},
                .outputs = {5},
                .type = TestOperationType::ADD
            }, {
                .inputs = {35, 36, 37},
                .outputs = {6},
                .type = TestOperationType::ADD
            }, {
                .inputs = {38, 39, 40},
                .outputs = {7},
                .type = TestOperationType::ADD
            }, {
                .inputs = {41, 42, 43},
                .outputs = {8},
                .type = TestOperationType::ADD
            }, {
                .inputs = {44, 45, 46},
                .outputs = {14},
                .type = TestOperationType::ADD
            }, {
                .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14},
                .outputs = {15, 16},
                .type = TestOperationType::QUANTIZED_16BIT_LSTM
            }},
        .outputIndexes = {15, 16}
    };
    return model;
}

}  // namespace generated_tests::quantized_lstm