path: root/nn/runtime/test/TestValidateModel.cpp

/*
 * Copyright (C) 2019 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <gtest/gtest.h>

#include "NeuralNetworks.h"

namespace {

class ValidateModelTest : public ::testing::Test {
   protected:
    virtual void SetUp() {}
};

TEST_F(ValidateModelTest, MaskRCNN2Go) {
    ANeuralNetworksModel* model = nullptr;
    ASSERT_EQ(ANeuralNetworksModel_create(&model), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_0{};
    operand_0.type = ANEURALNETWORKS_BOOL;
    operand_0.scale = 0;
    operand_0.zeroPoint = 0;
    operand_0.dimensionCount = 0;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_0), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_1{};
    operand_1.type = ANEURALNETWORKS_BOOL;
    operand_1.scale = 0;
    operand_1.zeroPoint = 0;
    operand_1.dimensionCount = 0;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_1), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_2{};
    operand_2.type = ANEURALNETWORKS_TENSOR_FLOAT32;
    operand_2.scale = 0;
    operand_2.zeroPoint = 0;
    operand_2.dimensionCount = 4;
    const uint32_t dimensions_2[] = {1, 3, 0, 0};
    operand_2.dimensions = dimensions_2;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_2), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_3{};
    operand_3.type = ANEURALNETWORKS_TENSOR_FLOAT32;
    operand_3.scale = 0;
    operand_3.zeroPoint = 0;
    operand_3.dimensionCount = 2;
    const uint32_t dimensions_3[] = {1, 3};
    operand_3.dimensions = dimensions_3;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_3), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_4{};
    operand_4.type = ANEURALNETWORKS_TENSOR_FLOAT32;
    operand_4.scale = 0;
    operand_4.zeroPoint = 0;
    operand_4.dimensionCount = 2;
    const uint32_t dimensions_4[] = {1, 2};
    operand_4.dimensions = dimensions_4;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_4), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_5{};
    operand_5.type = ANEURALNETWORKS_TENSOR_QUANT16_ASYMM;
    operand_5.scale = 0.125;
    operand_5.zeroPoint = 0;
    operand_5.dimensionCount = 2;
    const uint32_t dimensions_5[] = {1, 2};
    operand_5.dimensions = dimensions_5;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_5), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_6{};
    operand_6.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_6.scale = 0;
    operand_6.zeroPoint = 0;
    operand_6.dimensionCount = 1;
    const uint32_t dimensions_6[] = {4};
    operand_6.dimensions = dimensions_6;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_6), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_7{};
    operand_7.type = ANEURALNETWORKS_TENSOR_FLOAT32;
    operand_7.scale = 0;
    operand_7.zeroPoint = 0;
    operand_7.dimensionCount = 4;
    const uint32_t dimensions_7[] = {1, 0, 0, 3};
    operand_7.dimensions = dimensions_7;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_7), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_8{};
    operand_8.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_8.scale = 0.9891946315765381;
    operand_8.zeroPoint = 0;
    operand_8.dimensionCount = 4;
    const uint32_t dimensions_8[] = {1, 0, 0, 3};
    operand_8.dimensions = dimensions_8;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_8), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_9{};
    operand_9.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_9.scale = 5.880743992747739e-05;
    operand_9.zeroPoint = 95;
    operand_9.dimensionCount = 4;
    const uint32_t dimensions_9[] = {16, 3, 3, 3};
    operand_9.dimensions = dimensions_9;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_9), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_10{};
    operand_10.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_10.scale = 5.81720050831791e-05;
    operand_10.zeroPoint = 0;
    operand_10.dimensionCount = 1;
    const uint32_t dimensions_10[] = {16};
    operand_10.dimensions = dimensions_10;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_10), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_11{};
    operand_11.type = ANEURALNETWORKS_INT32;
    operand_11.scale = 0;
    operand_11.zeroPoint = 0;
    operand_11.dimensionCount = 0;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_11), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_12{};
    operand_12.type = ANEURALNETWORKS_INT32;
    operand_12.scale = 0;
    operand_12.zeroPoint = 0;
    operand_12.dimensionCount = 0;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_12), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_13{};
    operand_13.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_13.scale = 0.01966476067900658;
    operand_13.zeroPoint = 0;
    operand_13.dimensionCount = 4;
    const uint32_t dimensions_13[] = {1, 0, 0, 16};
    operand_13.dimensions = dimensions_13;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_13), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_14{};
    operand_14.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_14.scale = 0.01236020401120186;
    operand_14.zeroPoint = 94;
    operand_14.dimensionCount = 4;
    const uint32_t dimensions_14[] = {16, 1, 1, 16};
    operand_14.dimensions = dimensions_14;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_14), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_15{};
    operand_15.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_15.scale = 0.0002430604654364288;
    operand_15.zeroPoint = 0;
    operand_15.dimensionCount = 1;
    const uint32_t dimensions_15[] = {16};
    operand_15.dimensions = dimensions_15;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_15), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_16{};
    operand_16.type = ANEURALNETWORKS_INT32;
    operand_16.scale = 0;
    operand_16.zeroPoint = 0;
    operand_16.dimensionCount = 0;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_16), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_17{};
    operand_17.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_17.scale = 0.01199939660727978;
    operand_17.zeroPoint = 0;
    operand_17.dimensionCount = 4;
    const uint32_t dimensions_17[] = {1, 0, 0, 16};
    operand_17.dimensions = dimensions_17;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_17), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_18{};
    operand_18.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_18.scale = 0.006678132340312004;
    operand_18.zeroPoint = 124;
    operand_18.dimensionCount = 4;
    const uint32_t dimensions_18[] = {1, 3, 3, 16};
    operand_18.dimensions = dimensions_18;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_18), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_19{};
    operand_19.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_19.scale = 8.013355545699596e-05;
    operand_19.zeroPoint = 0;
    operand_19.dimensionCount = 1;
    const uint32_t dimensions_19[] = {16};
    operand_19.dimensions = dimensions_19;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_19), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_20{};
    operand_20.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_20.scale = 0.01280416082590818;
    operand_20.zeroPoint = 136;
    operand_20.dimensionCount = 4;
    const uint32_t dimensions_20[] = {1, 0, 0, 16};
    operand_20.dimensions = dimensions_20;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_20), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_21{};
    operand_21.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_21.scale = 0.02433430217206478;
    operand_21.zeroPoint = 111;
    operand_21.dimensionCount = 4;
    const uint32_t dimensions_21[] = {16, 1, 1, 16};
    operand_21.dimensions = dimensions_21;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_21), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_22{};
    operand_22.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_22.scale = 0.0003115803119726479;
    operand_22.zeroPoint = 0;
    operand_22.dimensionCount = 1;
    const uint32_t dimensions_22[] = {16};
    operand_22.dimensions = dimensions_22;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_22), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_23{};
    operand_23.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_23.scale = 0.04481548070907593;
    operand_23.zeroPoint = 132;
    operand_23.dimensionCount = 4;
    const uint32_t dimensions_23[] = {1, 0, 0, 16};
    operand_23.dimensions = dimensions_23;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_23), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_24{};
    operand_24.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_24.scale = 0.04634242877364159;
    operand_24.zeroPoint = 128;
    operand_24.dimensionCount = 4;
    const uint32_t dimensions_24[] = {1, 0, 0, 16};
    operand_24.dimensions = dimensions_24;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_24), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_25{};
    operand_25.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_25.scale = 0.005194671452045441;
    operand_25.zeroPoint = 158;
    operand_25.dimensionCount = 4;
    const uint32_t dimensions_25[] = {96, 1, 1, 16};
    operand_25.dimensions = dimensions_25;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_25), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_26{};
    operand_26.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_26.scale = 0.0002407336869509891;
    operand_26.zeroPoint = 0;
    operand_26.dimensionCount = 1;
    const uint32_t dimensions_26[] = {96};
    operand_26.dimensions = dimensions_26;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_26), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_27{};
    operand_27.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_27.scale = 0.01568881794810295;
    operand_27.zeroPoint = 0;
    operand_27.dimensionCount = 4;
    const uint32_t dimensions_27[] = {1, 0, 0, 96};
    operand_27.dimensions = dimensions_27;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_27), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_28{};
    operand_28.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_28.scale = 0.001355677493847907;
    operand_28.zeroPoint = 127;
    operand_28.dimensionCount = 4;
    const uint32_t dimensions_28[] = {1, 3, 3, 96};
    operand_28.dimensions = dimensions_28;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_28), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_29{};
    operand_29.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_29.scale = 2.126897743437439e-05;
    operand_29.zeroPoint = 0;
    operand_29.dimensionCount = 1;
    const uint32_t dimensions_29[] = {96};
    operand_29.dimensions = dimensions_29;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_29), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_30{};
    operand_30.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_30.scale = 0.01245978008955717;
    operand_30.zeroPoint = 123;
    operand_30.dimensionCount = 4;
    const uint32_t dimensions_30[] = {1, 0, 0, 96};
    operand_30.dimensions = dimensions_30;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_30), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_31{};
    operand_31.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_31.scale = 0.01157373003661633;
    operand_31.zeroPoint = 134;
    operand_31.dimensionCount = 4;
    const uint32_t dimensions_31[] = {32, 1, 1, 96};
    operand_31.dimensions = dimensions_31;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_31), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_32{};
    operand_32.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_32.scale = 0.000144206132972613;
    operand_32.zeroPoint = 0;
    operand_32.dimensionCount = 1;
    const uint32_t dimensions_32[] = {32};
    operand_32.dimensions = dimensions_32;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_32), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_33{};
    operand_33.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_33.scale = 0.01940538175404072;
    operand_33.zeroPoint = 135;
    operand_33.dimensionCount = 4;
    const uint32_t dimensions_33[] = {1, 0, 0, 32};
    operand_33.dimensions = dimensions_33;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_33), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_34{};
    operand_34.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_34.scale = 0.003280390985310078;
    operand_34.zeroPoint = 129;
    operand_34.dimensionCount = 4;
    const uint32_t dimensions_34[] = {192, 1, 1, 32};
    operand_34.dimensions = dimensions_34;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_34), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_35{};
    operand_35.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_35.scale = 6.365723675116897e-05;
    operand_35.zeroPoint = 0;
    operand_35.dimensionCount = 1;
    const uint32_t dimensions_35[] = {192};
    operand_35.dimensions = dimensions_35;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_35), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_36{};
    operand_36.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_36.scale = 0.005680288188159466;
    operand_36.zeroPoint = 0;
    operand_36.dimensionCount = 4;
    const uint32_t dimensions_36[] = {1, 0, 0, 192};
    operand_36.dimensions = dimensions_36;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_36), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_37{};
    operand_37.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_37.scale = 0.002816423308104277;
    operand_37.zeroPoint = 131;
    operand_37.dimensionCount = 4;
    const uint32_t dimensions_37[] = {1, 3, 3, 192};
    operand_37.dimensions = dimensions_37;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_37), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_38{};
    operand_38.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_38.scale = 1.599809547769837e-05;
    operand_38.zeroPoint = 0;
    operand_38.dimensionCount = 1;
    const uint32_t dimensions_38[] = {192};
    operand_38.dimensions = dimensions_38;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_38), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_39{};
    operand_39.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_39.scale = 0.002300027292221785;
    operand_39.zeroPoint = 111;
    operand_39.dimensionCount = 4;
    const uint32_t dimensions_39[] = {1, 0, 0, 192};
    operand_39.dimensions = dimensions_39;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_39), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_40{};
    operand_40.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_40.scale = 0.02601869031786919;
    operand_40.zeroPoint = 133;
    operand_40.dimensionCount = 4;
    const uint32_t dimensions_40[] = {32, 1, 1, 192};
    operand_40.dimensions = dimensions_40;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_40), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_41{};
    operand_41.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_41.scale = 5.984370000078343e-05;
    operand_41.zeroPoint = 0;
    operand_41.dimensionCount = 1;
    const uint32_t dimensions_41[] = {32};
    operand_41.dimensions = dimensions_41;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_41), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_42{};
    operand_42.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_42.scale = 0.01957281865179539;
    operand_42.zeroPoint = 126;
    operand_42.dimensionCount = 4;
    const uint32_t dimensions_42[] = {1, 0, 0, 32};
    operand_42.dimensions = dimensions_42;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_42), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_43{};
    operand_43.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_43.scale = 0.028990238904953;
    operand_43.zeroPoint = 123;
    operand_43.dimensionCount = 4;
    const uint32_t dimensions_43[] = {1, 0, 0, 32};
    operand_43.dimensions = dimensions_43;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_43), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_44{};
    operand_44.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_44.scale = 0.002658893587067723;
    operand_44.zeroPoint = 135;
    operand_44.dimensionCount = 4;
    const uint32_t dimensions_44[] = {192, 1, 1, 32};
    operand_44.dimensions = dimensions_44;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_44), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_45{};
    operand_45.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_45.scale = 7.708196062594652e-05;
    operand_45.zeroPoint = 0;
    operand_45.dimensionCount = 1;
    const uint32_t dimensions_45[] = {192};
    operand_45.dimensions = dimensions_45;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_45), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_46{};
    operand_46.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_46.scale = 0.009067215956747532;
    operand_46.zeroPoint = 0;
    operand_46.dimensionCount = 4;
    const uint32_t dimensions_46[] = {1, 0, 0, 192};
    operand_46.dimensions = dimensions_46;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_46), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_47{};
    operand_47.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_47.scale = 0.001217219163663685;
    operand_47.zeroPoint = 125;
    operand_47.dimensionCount = 4;
    const uint32_t dimensions_47[] = {1, 3, 3, 192};
    operand_47.dimensions = dimensions_47;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_47), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_48{};
    operand_48.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_48.scale = 1.103678914660122e-05;
    operand_48.zeroPoint = 0;
    operand_48.dimensionCount = 1;
    const uint32_t dimensions_48[] = {192};
    operand_48.dimensions = dimensions_48;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_48), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_49{};
    operand_49.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_49.scale = 0.003552014008164406;
    operand_49.zeroPoint = 130;
    operand_49.dimensionCount = 4;
    const uint32_t dimensions_49[] = {1, 0, 0, 192};
    operand_49.dimensions = dimensions_49;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_49), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_50{};
    operand_50.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_50.scale = 0.01093960553407669;
    operand_50.zeroPoint = 125;
    operand_50.dimensionCount = 4;
    const uint32_t dimensions_50[] = {48, 1, 1, 192};
    operand_50.dimensions = dimensions_50;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_50), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_51{};
    operand_51.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_51.scale = 3.885763362632133e-05;
    operand_51.zeroPoint = 0;
    operand_51.dimensionCount = 1;
    const uint32_t dimensions_51[] = {48};
    operand_51.dimensions = dimensions_51;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_51), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_52{};
    operand_52.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_52.scale = 0.01332638971507549;
    operand_52.zeroPoint = 115;
    operand_52.dimensionCount = 4;
    const uint32_t dimensions_52[] = {1, 0, 0, 48};
    operand_52.dimensions = dimensions_52;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_52), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_53{};
    operand_53.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_53.scale = 0.003872227622196078;
    operand_53.zeroPoint = 110;
    operand_53.dimensionCount = 4;
    const uint32_t dimensions_53[] = {288, 1, 1, 48};
    operand_53.dimensions = dimensions_53;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_53), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_54{};
    operand_54.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_54.scale = 5.160281580174342e-05;
    operand_54.zeroPoint = 0;
    operand_54.dimensionCount = 1;
    const uint32_t dimensions_54[] = {288};
    operand_54.dimensions = dimensions_54;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_54), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_55{};
    operand_55.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_55.scale = 0.005248025059700012;
    operand_55.zeroPoint = 0;
    operand_55.dimensionCount = 4;
    const uint32_t dimensions_55[] = {1, 0, 0, 288};
    operand_55.dimensions = dimensions_55;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_55), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_56{};
    operand_56.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_56.scale = 0.001976602710783482;
    operand_56.zeroPoint = 121;
    operand_56.dimensionCount = 4;
    const uint32_t dimensions_56[] = {1, 3, 3, 288};
    operand_56.dimensions = dimensions_56;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_56), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_57{};
    operand_57.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_57.scale = 1.037326001096517e-05;
    operand_57.zeroPoint = 0;
    operand_57.dimensionCount = 1;
    const uint32_t dimensions_57[] = {288};
    operand_57.dimensions = dimensions_57;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_57), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_58{};
    operand_58.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_58.scale = 0.001622712821699679;
    operand_58.zeroPoint = 128;
    operand_58.dimensionCount = 4;
    const uint32_t dimensions_58[] = {1, 0, 0, 288};
    operand_58.dimensions = dimensions_58;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_58), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_59{};
    operand_59.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_59.scale = 0.01881795562803745;
    operand_59.zeroPoint = 132;
    operand_59.dimensionCount = 4;
    const uint32_t dimensions_59[] = {48, 1, 1, 288};
    operand_59.dimensions = dimensions_59;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_59), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_60{};
    operand_60.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_60.scale = 3.053613909287378e-05;
    operand_60.zeroPoint = 0;
    operand_60.dimensionCount = 1;
    const uint32_t dimensions_60[] = {48};
    operand_60.dimensions = dimensions_60;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_60), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_61{};
    operand_61.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_61.scale = 0.01099279243499041;
    operand_61.zeroPoint = 126;
    operand_61.dimensionCount = 4;
    const uint32_t dimensions_61[] = {1, 0, 0, 48};
    operand_61.dimensions = dimensions_61;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_61), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_62{};
    operand_62.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_62.scale = 0.01927739381790161;
    operand_62.zeroPoint = 118;
    operand_62.dimensionCount = 4;
    const uint32_t dimensions_62[] = {1, 0, 0, 48};
    operand_62.dimensions = dimensions_62;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_62), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_63{};
    operand_63.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_63.scale = 0.00215660990215838;
    operand_63.zeroPoint = 111;
    operand_63.dimensionCount = 4;
    const uint32_t dimensions_63[] = {288, 1, 1, 48};
    operand_63.dimensions = dimensions_63;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_63), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_64{};
    operand_64.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_64.scale = 4.157381772529334e-05;
    operand_64.zeroPoint = 0;
    operand_64.dimensionCount = 1;
    const uint32_t dimensions_64[] = {288};
    operand_64.dimensions = dimensions_64;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_64), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_65{};
    operand_65.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_65.scale = 0.004311998840421438;
    operand_65.zeroPoint = 0;
    operand_65.dimensionCount = 4;
    const uint32_t dimensions_65[] = {1, 0, 0, 288};
    operand_65.dimensions = dimensions_65;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_65), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_66{};
    operand_66.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_66.scale = 0.001798613811843097;
    operand_66.zeroPoint = 128;
    operand_66.dimensionCount = 4;
    const uint32_t dimensions_66[] = {1, 3, 3, 288};
    operand_66.dimensions = dimensions_66;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_66), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_67{};
    operand_67.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_67.scale = 7.755620572424959e-06;
    operand_67.zeroPoint = 0;
    operand_67.dimensionCount = 1;
    const uint32_t dimensions_67[] = {288};
    operand_67.dimensions = dimensions_67;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_67), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_68{};
    operand_68.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_68.scale = 0.001595283509232104;
    operand_68.zeroPoint = 122;
    operand_68.dimensionCount = 4;
    const uint32_t dimensions_68[] = {1, 0, 0, 288};
    operand_68.dimensions = dimensions_68;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_68), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_69{};
    operand_69.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_69.scale = 0.02731921337544918;
    operand_69.zeroPoint = 136;
    operand_69.dimensionCount = 4;
    const uint32_t dimensions_69[] = {48, 1, 1, 288};
    operand_69.dimensions = dimensions_69;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_69), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_70{};
    operand_70.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_70.scale = 4.358188743935898e-05;
    operand_70.zeroPoint = 0;
    operand_70.dimensionCount = 1;
    const uint32_t dimensions_70[] = {48};
    operand_70.dimensions = dimensions_70;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_70), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_71{};
    operand_71.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_71.scale = 0.01208362448960543;
    operand_71.zeroPoint = 120;
    operand_71.dimensionCount = 4;
    const uint32_t dimensions_71[] = {1, 0, 0, 48};
    operand_71.dimensions = dimensions_71;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_71), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_72{};
    operand_72.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_72.scale = 0.02560163103044033;
    operand_72.zeroPoint = 107;
    operand_72.dimensionCount = 4;
    const uint32_t dimensions_72[] = {1, 0, 0, 48};
    operand_72.dimensions = dimensions_72;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_72), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_73{};
    operand_73.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_73.scale = 0.003050966653972864;
    operand_73.zeroPoint = 125;
    operand_73.dimensionCount = 4;
    const uint32_t dimensions_73[] = {288, 1, 1, 48};
    operand_73.dimensions = dimensions_73;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_73), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_74{};
    operand_74.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_74.scale = 7.810971874278039e-05;
    operand_74.zeroPoint = 0;
    operand_74.dimensionCount = 1;
    const uint32_t dimensions_74[] = {288};
    operand_74.dimensions = dimensions_74;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_74), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_75{};
    operand_75.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_75.scale = 0.01042873691767454;
    operand_75.zeroPoint = 0;
    operand_75.dimensionCount = 4;
    const uint32_t dimensions_75[] = {1, 0, 0, 288};
    operand_75.dimensions = dimensions_75;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_75), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_76{};
    operand_76.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_76.scale = 0.00121846969705075;
    operand_76.zeroPoint = 117;
    operand_76.dimensionCount = 4;
    const uint32_t dimensions_76[] = {1, 3, 3, 288};
    operand_76.dimensions = dimensions_76;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_76), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_77{};
    operand_77.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_77.scale = 1.270709981326945e-05;
    operand_77.zeroPoint = 0;
    operand_77.dimensionCount = 1;
    const uint32_t dimensions_77[] = {288};
    operand_77.dimensions = dimensions_77;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_77), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_78{};
    operand_78.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_78.scale = 0.002883265493437648;
    operand_78.zeroPoint = 137;
    operand_78.dimensionCount = 4;
    const uint32_t dimensions_78[] = {1, 0, 0, 288};
    operand_78.dimensions = dimensions_78;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_78), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_79{};
    operand_79.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_79.scale = 0.009875123389065266;
    operand_79.zeroPoint = 131;
    operand_79.dimensionCount = 4;
    const uint32_t dimensions_79[] = {96, 1, 1, 288};
    operand_79.dimensions = dimensions_79;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_79), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_80{};
    operand_80.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_80.scale = 2.847260293492582e-05;
    operand_80.zeroPoint = 0;
    operand_80.dimensionCount = 1;
    const uint32_t dimensions_80[] = {96};
    operand_80.dimensions = dimensions_80;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_80), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_81{};
    operand_81.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_81.scale = 0.009474765509366989;
    operand_81.zeroPoint = 115;
    operand_81.dimensionCount = 4;
    const uint32_t dimensions_81[] = {1, 0, 0, 96};
    operand_81.dimensions = dimensions_81;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_81), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_82{};
    operand_82.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_82.scale = 0.00323105463758111;
    operand_82.zeroPoint = 121;
    operand_82.dimensionCount = 4;
    const uint32_t dimensions_82[] = {576, 1, 1, 96};
    operand_82.dimensions = dimensions_82;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_82), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_83{};
    operand_83.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_83.scale = 3.061348616029136e-05;
    operand_83.zeroPoint = 0;
    operand_83.dimensionCount = 1;
    const uint32_t dimensions_83[] = {576};
    operand_83.dimensions = dimensions_83;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_83), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_84{};
    operand_84.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_84.scale = 0.004371246788650751;
    operand_84.zeroPoint = 0;
    operand_84.dimensionCount = 4;
    const uint32_t dimensions_84[] = {1, 0, 0, 576};
    operand_84.dimensions = dimensions_84;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_84), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_85{};
    operand_85.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_85.scale = 0.001316901994869113;
    operand_85.zeroPoint = 132;
    operand_85.dimensionCount = 4;
    const uint32_t dimensions_85[] = {1, 3, 3, 576};
    operand_85.dimensions = dimensions_85;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_85), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_86{};
    operand_86.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_86.scale = 5.75650346945622e-06;
    operand_86.zeroPoint = 0;
    operand_86.dimensionCount = 1;
    const uint32_t dimensions_86[] = {576};
    operand_86.dimensions = dimensions_86;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_86), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_87{};
    operand_87.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_87.scale = 0.001160673331469297;
    operand_87.zeroPoint = 136;
    operand_87.dimensionCount = 4;
    const uint32_t dimensions_87[] = {1, 0, 0, 576};
    operand_87.dimensions = dimensions_87;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_87), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_88{};
    operand_88.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_88.scale = 0.01717966049909592;
    operand_88.zeroPoint = 138;
    operand_88.dimensionCount = 4;
    const uint32_t dimensions_88[] = {96, 1, 1, 576};
    operand_88.dimensions = dimensions_88;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_88), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_89{};
    operand_89.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_89.scale = 1.993997466342989e-05;
    operand_89.zeroPoint = 0;
    operand_89.dimensionCount = 1;
    const uint32_t dimensions_89[] = {96};
    operand_89.dimensions = dimensions_89;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_89), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_90{};
    operand_90.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_90.scale = 0.006981693673878908;
    operand_90.zeroPoint = 120;
    operand_90.dimensionCount = 4;
    const uint32_t dimensions_90[] = {1, 0, 0, 96};
    operand_90.dimensions = dimensions_90;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_90), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_91{};
    operand_91.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_91.scale = 0.01042260229587555;
    operand_91.zeroPoint = 124;
    operand_91.dimensionCount = 4;
    const uint32_t dimensions_91[] = {1, 0, 0, 96};
    operand_91.dimensions = dimensions_91;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_91), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_92{};
    operand_92.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_92.scale = 0.002388325287029147;
    operand_92.zeroPoint = 120;
    operand_92.dimensionCount = 4;
    const uint32_t dimensions_92[] = {576, 1, 1, 96};
    operand_92.dimensions = dimensions_92;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_92), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_93{};
    operand_93.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_93.scale = 2.489256439730525e-05;
    operand_93.zeroPoint = 0;
    operand_93.dimensionCount = 1;
    const uint32_t dimensions_93[] = {576};
    operand_93.dimensions = dimensions_93;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_93), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_94{};
    operand_94.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_94.scale = 0.003468555863946676;
    operand_94.zeroPoint = 0;
    operand_94.dimensionCount = 4;
    const uint32_t dimensions_94[] = {1, 0, 0, 576};
    operand_94.dimensions = dimensions_94;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_94), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_95{};
    operand_95.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_95.scale = 0.001293058856390417;
    operand_95.zeroPoint = 135;
    operand_95.dimensionCount = 4;
    const uint32_t dimensions_95[] = {1, 3, 3, 576};
    operand_95.dimensions = dimensions_95;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_95), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_96{};
    operand_96.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_96.scale = 4.485046702029649e-06;
    operand_96.zeroPoint = 0;
    operand_96.dimensionCount = 1;
    const uint32_t dimensions_96[] = {576};
    operand_96.dimensions = dimensions_96;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_96), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_97{};
    operand_97.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_97.scale = 0.001004486111924052;
    operand_97.zeroPoint = 121;
    operand_97.dimensionCount = 4;
    const uint32_t dimensions_97[] = {1, 0, 0, 576};
    operand_97.dimensions = dimensions_97;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_97), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_98{};
    operand_98.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_98.scale = 0.02229274623095989;
    operand_98.zeroPoint = 132;
    operand_98.dimensionCount = 4;
    const uint32_t dimensions_98[] = {96, 1, 1, 576};
    operand_98.dimensions = dimensions_98;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_98), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_99{};
    operand_99.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_99.scale = 2.239275454485323e-05;
    operand_99.zeroPoint = 0;
    operand_99.dimensionCount = 1;
    const uint32_t dimensions_99[] = {96};
    operand_99.dimensions = dimensions_99;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_99), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_100{};
    operand_100.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_100.scale = 0.00858442485332489;
    operand_100.zeroPoint = 128;
    operand_100.dimensionCount = 4;
    const uint32_t dimensions_100[] = {1, 0, 0, 96};
    operand_100.dimensions = dimensions_100;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_100), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_101{};
    operand_101.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_101.scale = 0.01262346189469099;
    operand_101.zeroPoint = 130;
    operand_101.dimensionCount = 4;
    const uint32_t dimensions_101[] = {1, 0, 0, 96};
    operand_101.dimensions = dimensions_101;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_101), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_102{};
    operand_102.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_102.scale = 0.001790200243704021;
    operand_102.zeroPoint = 143;
    operand_102.dimensionCount = 4;
    const uint32_t dimensions_102[] = {576, 1, 1, 96};
    operand_102.dimensions = dimensions_102;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_102), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_103{};
    operand_103.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_103.scale = 2.259852408315055e-05;
    operand_103.zeroPoint = 0;
    operand_103.dimensionCount = 1;
    const uint32_t dimensions_103[] = {576};
    operand_103.dimensions = dimensions_103;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_103), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_104{};
    operand_104.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_104.scale = 0.003789969952777028;
    operand_104.zeroPoint = 0;
    operand_104.dimensionCount = 4;
    const uint32_t dimensions_104[] = {1, 0, 0, 576};
    operand_104.dimensions = dimensions_104;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_104), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_105{};
    operand_105.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_105.scale = 0.001565286540426314;
    operand_105.zeroPoint = 133;
    operand_105.dimensionCount = 4;
    const uint32_t dimensions_105[] = {1, 3, 3, 576};
    operand_105.dimensions = dimensions_105;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_105), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_106{};
    operand_106.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_106.scale = 5.932388830842683e-06;
    operand_106.zeroPoint = 0;
    operand_106.dimensionCount = 1;
    const uint32_t dimensions_106[] = {576};
    operand_106.dimensions = dimensions_106;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_106), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_107{};
    operand_107.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_107.scale = 0.001188441878184676;
    operand_107.zeroPoint = 107;
    operand_107.dimensionCount = 4;
    const uint32_t dimensions_107[] = {1, 0, 0, 576};
    operand_107.dimensions = dimensions_107;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_107), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_108{};
    operand_108.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_108.scale = 0.03223617374897003;
    operand_108.zeroPoint = 131;
    operand_108.dimensionCount = 4;
    const uint32_t dimensions_108[] = {96, 1, 1, 576};
    operand_108.dimensions = dimensions_108;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_108), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_109{};
    operand_109.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_109.scale = 3.83108199457638e-05;
    operand_109.zeroPoint = 0;
    operand_109.dimensionCount = 1;
    const uint32_t dimensions_109[] = {96};
    operand_109.dimensions = dimensions_109;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_109), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_110{};
    operand_110.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_110.scale = 0.01084044575691223;
    operand_110.zeroPoint = 130;
    operand_110.dimensionCount = 4;
    const uint32_t dimensions_110[] = {1, 0, 0, 96};
    operand_110.dimensions = dimensions_110;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_110), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_111{};
    operand_111.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_111.scale = 0.01627451553940773;
    operand_111.zeroPoint = 133;
    operand_111.dimensionCount = 4;
    const uint32_t dimensions_111[] = {1, 0, 0, 96};
    operand_111.dimensions = dimensions_111;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_111), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_112{};
    operand_112.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_112.scale = 0.001678385655395687;
    operand_112.zeroPoint = 135;
    operand_112.dimensionCount = 4;
    const uint32_t dimensions_112[] = {576, 1, 1, 96};
    operand_112.dimensions = dimensions_112;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_112), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_113{};
    operand_113.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_113.scale = 2.731491440499667e-05;
    operand_113.zeroPoint = 0;
    operand_113.dimensionCount = 1;
    const uint32_t dimensions_113[] = {576};
    operand_113.dimensions = dimensions_113;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_113), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_114{};
    operand_114.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_114.scale = 0.004788670688867569;
    operand_114.zeroPoint = 0;
    operand_114.dimensionCount = 4;
    const uint32_t dimensions_114[] = {1, 0, 0, 576};
    operand_114.dimensions = dimensions_114;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_114), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_115{};
    operand_115.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_115.scale = 0.001882086275145411;
    operand_115.zeroPoint = 130;
    operand_115.dimensionCount = 4;
    const uint32_t dimensions_115[] = {1, 3, 3, 576};
    operand_115.dimensions = dimensions_115;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_115), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_116{};
    operand_116.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_116.scale = 9.012691407406237e-06;
    operand_116.zeroPoint = 0;
    operand_116.dimensionCount = 1;
    const uint32_t dimensions_116[] = {576};
    operand_116.dimensions = dimensions_116;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_116), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_117{};
    operand_117.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_117.scale = 0.001888960134238005;
    operand_117.zeroPoint = 131;
    operand_117.dimensionCount = 4;
    const uint32_t dimensions_117[] = {1, 0, 0, 576};
    operand_117.dimensions = dimensions_117;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_117), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_118{};
    operand_118.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_118.scale = 0.006059954408556223;
    operand_118.zeroPoint = 131;
    operand_118.dimensionCount = 4;
    const uint32_t dimensions_118[] = {128, 1, 1, 576};
    operand_118.dimensions = dimensions_118;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_118), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_119{};
    operand_119.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_119.scale = 1.144701218436239e-05;
    operand_119.zeroPoint = 0;
    operand_119.dimensionCount = 1;
    const uint32_t dimensions_119[] = {128};
    operand_119.dimensions = dimensions_119;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_119), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_120{};
    operand_120.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_120.scale = 0.004614091943949461;
    operand_120.zeroPoint = 131;
    operand_120.dimensionCount = 4;
    const uint32_t dimensions_120[] = {1, 0, 0, 128};
    operand_120.dimensions = dimensions_120;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_120), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_121{};
    operand_121.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_121.scale = 0.007414539344608784;
    operand_121.zeroPoint = 126;
    operand_121.dimensionCount = 4;
    const uint32_t dimensions_121[] = {768, 1, 1, 128};
    operand_121.dimensions = dimensions_121;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_121), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_122{};
    operand_122.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_122.scale = 3.42113635269925e-05;
    operand_122.zeroPoint = 0;
    operand_122.dimensionCount = 1;
    const uint32_t dimensions_122[] = {768};
    operand_122.dimensions = dimensions_122;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_122), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_123{};
    operand_123.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_123.scale = 0.002970855450257659;
    operand_123.zeroPoint = 0;
    operand_123.dimensionCount = 4;
    const uint32_t dimensions_123[] = {1, 0, 0, 768};
    operand_123.dimensions = dimensions_123;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_123), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_124{};
    operand_124.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_124.scale = 0.00154426705557853;
    operand_124.zeroPoint = 127;
    operand_124.dimensionCount = 4;
    const uint32_t dimensions_124[] = {1, 3, 3, 768};
    operand_124.dimensions = dimensions_124;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_124), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_125{};
    operand_125.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_125.scale = 4.58779413747834e-06;
    operand_125.zeroPoint = 0;
    operand_125.dimensionCount = 1;
    const uint32_t dimensions_125[] = {768};
    operand_125.dimensions = dimensions_125;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_125), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_126{};
    operand_126.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_126.scale = 0.001004609395749867;
    operand_126.zeroPoint = 119;
    operand_126.dimensionCount = 4;
    const uint32_t dimensions_126[] = {1, 0, 0, 768};
    operand_126.dimensions = dimensions_126;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_126), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_127{};
    operand_127.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_127.scale = 0.01107242610305548;
    operand_127.zeroPoint = 127;
    operand_127.dimensionCount = 4;
    const uint32_t dimensions_127[] = {128, 1, 1, 768};
    operand_127.dimensions = dimensions_127;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_127), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_128{};
    operand_128.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_128.scale = 1.112346308218548e-05;
    operand_128.zeroPoint = 0;
    operand_128.dimensionCount = 1;
    const uint32_t dimensions_128[] = {128};
    operand_128.dimensions = dimensions_128;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_128), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_129{};
    operand_129.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_129.scale = 0.004491065628826618;
    operand_129.zeroPoint = 121;
    operand_129.dimensionCount = 4;
    const uint32_t dimensions_129[] = {1, 0, 0, 128};
    operand_129.dimensions = dimensions_129;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_129), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_130{};
    operand_130.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_130.scale = 0.007918111048638821;
    operand_130.zeroPoint = 132;
    operand_130.dimensionCount = 4;
    const uint32_t dimensions_130[] = {1, 0, 0, 128};
    operand_130.dimensions = dimensions_130;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_130), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_131{};
    operand_131.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_131.scale = 0.004637615289539099;
    operand_131.zeroPoint = 126;
    operand_131.dimensionCount = 4;
    const uint32_t dimensions_131[] = {768, 1, 1, 128};
    operand_131.dimensions = dimensions_131;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_131), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_132{};
    operand_132.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_132.scale = 3.672115417430177e-05;
    operand_132.zeroPoint = 0;
    operand_132.dimensionCount = 1;
    const uint32_t dimensions_132[] = {768};
    operand_132.dimensions = dimensions_132;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_132), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_133{};
    operand_133.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_133.scale = 0.003131674602627754;
    operand_133.zeroPoint = 0;
    operand_133.dimensionCount = 4;
    const uint32_t dimensions_133[] = {1, 0, 0, 768};
    operand_133.dimensions = dimensions_133;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_133), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_134{};
    operand_134.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_134.scale = 0.001537951757200062;
    operand_134.zeroPoint = 130;
    operand_134.dimensionCount = 4;
    const uint32_t dimensions_134[] = {1, 3, 3, 768};
    operand_134.dimensions = dimensions_134;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_134), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_135{};
    operand_135.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_135.scale = 4.816364707949106e-06;
    operand_135.zeroPoint = 0;
    operand_135.dimensionCount = 1;
    const uint32_t dimensions_135[] = {768};
    operand_135.dimensions = dimensions_135;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_135), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_136{};
    operand_136.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_136.scale = 0.001004835939966142;
    operand_136.zeroPoint = 121;
    operand_136.dimensionCount = 4;
    const uint32_t dimensions_136[] = {1, 0, 0, 768};
    operand_136.dimensions = dimensions_136;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_136), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_137{};
    operand_137.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_137.scale = 0.01529518887400627;
    operand_137.zeroPoint = 131;
    operand_137.dimensionCount = 4;
    const uint32_t dimensions_137[] = {128, 1, 1, 768};
    operand_137.dimensions = dimensions_137;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_137), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_138{};
    operand_138.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_138.scale = 1.536915442557074e-05;
    operand_138.zeroPoint = 0;
    operand_138.dimensionCount = 1;
    const uint32_t dimensions_138[] = {128};
    operand_138.dimensions = dimensions_138;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_138), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_139{};
    operand_139.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_139.scale = 0.005413023289293051;
    operand_139.zeroPoint = 121;
    operand_139.dimensionCount = 4;
    const uint32_t dimensions_139[] = {1, 0, 0, 128};
    operand_139.dimensions = dimensions_139;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_139), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_140{};
    operand_140.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_140.scale = 0.01041953638195992;
    operand_140.zeroPoint = 122;
    operand_140.dimensionCount = 4;
    const uint32_t dimensions_140[] = {1, 0, 0, 128};
    operand_140.dimensions = dimensions_140;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_140), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_141{};
    operand_141.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_141.scale = 0.002339381724596024;
    operand_141.zeroPoint = 119;
    operand_141.dimensionCount = 4;
    const uint32_t dimensions_141[] = {768, 1, 1, 128};
    operand_141.dimensions = dimensions_141;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_141), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_142{};
    operand_142.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_142.scale = 2.437527291476727e-05;
    operand_142.zeroPoint = 0;
    operand_142.dimensionCount = 1;
    const uint32_t dimensions_142[] = {768};
    operand_142.dimensions = dimensions_142;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_142), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_143{};
    operand_143.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_143.scale = 0.002237820532172918;
    operand_143.zeroPoint = 0;
    operand_143.dimensionCount = 4;
    const uint32_t dimensions_143[] = {1, 0, 0, 768};
    operand_143.dimensions = dimensions_143;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_143), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_144{};
    operand_144.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_144.scale = 0.0007936766487546265;
    operand_144.zeroPoint = 133;
    operand_144.dimensionCount = 4;
    const uint32_t dimensions_144[] = {1, 3, 3, 768};
    operand_144.dimensions = dimensions_144;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_144), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_145{};
    operand_145.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_145.scale = 1.776105818862561e-06;
    operand_145.zeroPoint = 0;
    operand_145.dimensionCount = 1;
    const uint32_t dimensions_145[] = {768};
    operand_145.dimensions = dimensions_145;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_145), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_146{};
    operand_146.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_146.scale = 0.001001776661723852;
    operand_146.zeroPoint = 115;
    operand_146.dimensionCount = 4;
    const uint32_t dimensions_146[] = {1, 0, 0, 768};
    operand_146.dimensions = dimensions_146;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_146), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_147{};
    operand_147.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_147.scale = 0.02992645651102066;
    operand_147.zeroPoint = 122;
    operand_147.dimensionCount = 4;
    const uint32_t dimensions_147[] = {128, 1, 1, 768};
    operand_147.dimensions = dimensions_147;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_147), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_148{};
    operand_148.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_148.scale = 2.997962474182714e-05;
    operand_148.zeroPoint = 0;
    operand_148.dimensionCount = 1;
    const uint32_t dimensions_148[] = {128};
    operand_148.dimensions = dimensions_148;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_148), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_149{};
    operand_149.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_149.scale = 0.006007113959640265;
    operand_149.zeroPoint = 138;
    operand_149.dimensionCount = 4;
    const uint32_t dimensions_149[] = {1, 0, 0, 128};
    operand_149.dimensions = dimensions_149;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_149), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_150{};
    operand_150.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_150.scale = 0.01333596650511026;
    operand_150.zeroPoint = 128;
    operand_150.dimensionCount = 4;
    const uint32_t dimensions_150[] = {1, 0, 0, 128};
    operand_150.dimensions = dimensions_150;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_150), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_151{};
    operand_151.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_151.scale = 0.002114560455083847;
    operand_151.zeroPoint = 131;
    operand_151.dimensionCount = 4;
    const uint32_t dimensions_151[] = {768, 1, 1, 128};
    operand_151.dimensions = dimensions_151;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_151), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_152{};
    operand_152.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_152.scale = 2.819970904965885e-05;
    operand_152.zeroPoint = 0;
    operand_152.dimensionCount = 1;
    const uint32_t dimensions_152[] = {768};
    operand_152.dimensions = dimensions_152;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_152), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_153{};
    operand_153.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_153.scale = 0.002463524229824543;
    operand_153.zeroPoint = 0;
    operand_153.dimensionCount = 4;
    const uint32_t dimensions_153[] = {1, 0, 0, 768};
    operand_153.dimensions = dimensions_153;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_153), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_154{};
    operand_154.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_154.scale = 0.0009068828076124191;
    operand_154.zeroPoint = 125;
    operand_154.dimensionCount = 4;
    const uint32_t dimensions_154[] = {1, 3, 3, 768};
    operand_154.dimensions = dimensions_154;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_154), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_155{};
    operand_155.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_155.scale = 2.234127578049083e-06;
    operand_155.zeroPoint = 0;
    operand_155.dimensionCount = 1;
    const uint32_t dimensions_155[] = {768};
    operand_155.dimensions = dimensions_155;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_155), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_156{};
    operand_156.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_156.scale = 0.001002233359031379;
    operand_156.zeroPoint = 132;
    operand_156.dimensionCount = 4;
    const uint32_t dimensions_156[] = {1, 0, 0, 768};
    operand_156.dimensions = dimensions_156;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_156), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_157{};
    operand_157.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_157.scale = 0.0339314192533493;
    operand_157.zeroPoint = 113;
    operand_157.dimensionCount = 4;
    const uint32_t dimensions_157[] = {128, 1, 1, 768};
    operand_157.dimensions = dimensions_157;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_157), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_158{};
    operand_158.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_158.scale = 3.400720015633851e-05;
    operand_158.zeroPoint = 0;
    operand_158.dimensionCount = 1;
    const uint32_t dimensions_158[] = {128};
    operand_158.dimensions = dimensions_158;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_158), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_159{};
    operand_159.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_159.scale = 0.007420019246637821;
    operand_159.zeroPoint = 135;
    operand_159.dimensionCount = 4;
    const uint32_t dimensions_159[] = {1, 0, 0, 128};
    operand_159.dimensions = dimensions_159;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_159), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_160{};
    operand_160.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_160.scale = 0.01803975738584995;
    operand_160.zeroPoint = 134;
    operand_160.dimensionCount = 4;
    const uint32_t dimensions_160[] = {1, 0, 0, 128};
    operand_160.dimensions = dimensions_160;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_160), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_161{};
    operand_161.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_161.scale = 0.001758694183081388;
    operand_161.zeroPoint = 134;
    operand_161.dimensionCount = 4;
    const uint32_t dimensions_161[] = {768, 1, 1, 128};
    operand_161.dimensions = dimensions_161;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_161), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_162{};
    operand_162.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_162.scale = 3.172641663695686e-05;
    operand_162.zeroPoint = 0;
    operand_162.dimensionCount = 1;
    const uint32_t dimensions_162[] = {768};
    operand_162.dimensions = dimensions_162;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_162), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_163{};
    operand_163.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_163.scale = 0.003602873533964157;
    operand_163.zeroPoint = 0;
    operand_163.dimensionCount = 4;
    const uint32_t dimensions_163[] = {1, 0, 0, 768};
    operand_163.dimensions = dimensions_163;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_163), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_164{};
    operand_164.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_164.scale = 0.00123634107876569;
    operand_164.zeroPoint = 134;
    operand_164.dimensionCount = 4;
    const uint32_t dimensions_164[] = {1, 3, 3, 768};
    operand_164.dimensions = dimensions_164;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_164), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_165{};
    operand_165.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_165.scale = 4.45438035967527e-06;
    operand_165.zeroPoint = 0;
    operand_165.dimensionCount = 1;
    const uint32_t dimensions_165[] = {768};
    operand_165.dimensions = dimensions_165;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_165), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_166{};
    operand_166.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_166.scale = 0.001004456076771021;
    operand_166.zeroPoint = 114;
    operand_166.dimensionCount = 4;
    const uint32_t dimensions_166[] = {1, 0, 0, 768};
    operand_166.dimensions = dimensions_166;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_166), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_167{};
    operand_167.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_167.scale = 0.04360251501202583;
    operand_167.zeroPoint = 125;
    operand_167.dimensionCount = 4;
    const uint32_t dimensions_167[] = {128, 1, 1, 768};
    operand_167.dimensions = dimensions_167;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_167), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_168{};
    operand_168.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_168.scale = 4.379680831334554e-05;
    operand_168.zeroPoint = 0;
    operand_168.dimensionCount = 1;
    const uint32_t dimensions_168[] = {128};
    operand_168.dimensions = dimensions_168;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_168), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_169{};
    operand_169.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_169.scale = 0.01710499450564384;
    operand_169.zeroPoint = 129;
    operand_169.dimensionCount = 4;
    const uint32_t dimensions_169[] = {1, 0, 0, 128};
    operand_169.dimensions = dimensions_169;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_169), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_170{};
    operand_170.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_170.scale = 0.02661834843456745;
    operand_170.zeroPoint = 134;
    operand_170.dimensionCount = 4;
    const uint32_t dimensions_170[] = {1, 0, 0, 128};
    operand_170.dimensions = dimensions_170;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_170), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_171{};
    operand_171.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_171.scale = 0.003064587479457259;
    operand_171.zeroPoint = 115;
    operand_171.dimensionCount = 4;
    const uint32_t dimensions_171[] = {15, 1, 1, 128};
    operand_171.dimensions = dimensions_171;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_171), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_172{};
    operand_172.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_172.scale = 8.157426054822281e-05;
    operand_172.zeroPoint = 0;
    operand_172.dimensionCount = 1;
    const uint32_t dimensions_172[] = {15};
    operand_172.dimensions = dimensions_172;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_172), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_173{};
    operand_173.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_173.scale = 0.08332997560501099;
    operand_173.zeroPoint = 148;
    operand_173.dimensionCount = 4;
    const uint32_t dimensions_173[] = {1, 0, 0, 15};
    operand_173.dimensions = dimensions_173;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_173), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_174{};
    operand_174.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_174.scale = 0.0009250070434063673;
    operand_174.zeroPoint = 131;
    operand_174.dimensionCount = 4;
    const uint32_t dimensions_174[] = {60, 1, 1, 128};
    operand_174.dimensions = dimensions_174;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_174), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_175{};
    operand_175.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_175.scale = 2.462215888954233e-05;
    operand_175.zeroPoint = 0;
    operand_175.dimensionCount = 1;
    const uint32_t dimensions_175[] = {60};
    operand_175.dimensions = dimensions_175;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_175), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_176{};
    operand_176.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_176.scale = 0.008264735341072083;
    operand_176.zeroPoint = 137;
    operand_176.dimensionCount = 4;
    const uint32_t dimensions_176[] = {1, 0, 0, 60};
    operand_176.dimensions = dimensions_176;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_176), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_177{};
    operand_177.type = ANEURALNETWORKS_TENSOR_QUANT16_SYMM;
    operand_177.scale = 0.125;
    operand_177.zeroPoint = 0;
    operand_177.dimensionCount = 2;
    const uint32_t dimensions_177[] = {15, 4};
    operand_177.dimensions = dimensions_177;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_177), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_178{};
    operand_178.type = ANEURALNETWORKS_FLOAT32;
    operand_178.scale = 0;
    operand_178.zeroPoint = 0;
    operand_178.dimensionCount = 0;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_178), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_179{};
    operand_179.type = ANEURALNETWORKS_INT32;
    operand_179.scale = 0;
    operand_179.zeroPoint = 0;
    operand_179.dimensionCount = 0;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_179), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_180{};
    operand_180.type = ANEURALNETWORKS_INT32;
    operand_180.scale = 0;
    operand_180.zeroPoint = 0;
    operand_180.dimensionCount = 0;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_180), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_181{};
    operand_181.type = ANEURALNETWORKS_FLOAT32;
    operand_181.scale = 0;
    operand_181.zeroPoint = 0;
    operand_181.dimensionCount = 0;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_181), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_182{};
    operand_182.type = ANEURALNETWORKS_FLOAT32;
    operand_182.scale = 0;
    operand_182.zeroPoint = 0;
    operand_182.dimensionCount = 0;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_182), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_183{};
    operand_183.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_183.scale = 0.08332997560501099;
    operand_183.zeroPoint = 148;
    operand_183.dimensionCount = 1;
    const uint32_t dimensions_183[] = {0};
    operand_183.dimensions = dimensions_183;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_183), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_184{};
    operand_184.type = ANEURALNETWORKS_TENSOR_QUANT16_ASYMM;
    operand_184.scale = 0.125;
    operand_184.zeroPoint = 0;
    operand_184.dimensionCount = 2;
    const uint32_t dimensions_184[] = {0, 4};
    operand_184.dimensions = dimensions_184;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_184), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_185{};
    operand_185.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_185.scale = 0;
    operand_185.zeroPoint = 0;
    operand_185.dimensionCount = 1;
    const uint32_t dimensions_185[] = {0};
    operand_185.dimensions = dimensions_185;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_185), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_186{};
    operand_186.type = ANEURALNETWORKS_INT32;
    operand_186.scale = 0;
    operand_186.zeroPoint = 0;
    operand_186.dimensionCount = 0;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_186), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_187{};
    operand_187.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_187.scale = 0.009147729724645615;
    operand_187.zeroPoint = 121;
    operand_187.dimensionCount = 4;
    const uint32_t dimensions_187[] = {0, 6, 6, 128};
    operand_187.dimensions = dimensions_187;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_187), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_188{};
    operand_188.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_188.scale = 0.003680879715830088;
    operand_188.zeroPoint = 146;
    operand_188.dimensionCount = 4;
    const uint32_t dimensions_188[] = {512, 1, 1, 128};
    operand_188.dimensions = dimensions_188;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_188), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_189{};
    operand_189.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_189.scale = 3.367169483681209e-05;
    operand_189.zeroPoint = 0;
    operand_189.dimensionCount = 1;
    const uint32_t dimensions_189[] = {512};
    operand_189.dimensions = dimensions_189;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_189), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_190{};
    operand_190.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_190.scale = 0.003791309893131256;
    operand_190.zeroPoint = 0;
    operand_190.dimensionCount = 4;
    const uint32_t dimensions_190[] = {0, 6, 6, 512};
    operand_190.dimensions = dimensions_190;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_190), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_191{};
    operand_191.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_191.scale = 0.001269564847461879;
    operand_191.zeroPoint = 138;
    operand_191.dimensionCount = 4;
    const uint32_t dimensions_191[] = {1, 3, 3, 512};
    operand_191.dimensions = dimensions_191;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_191), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_192{};
    operand_192.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_192.scale = 4.813313807972008e-06;
    operand_192.zeroPoint = 0;
    operand_192.dimensionCount = 1;
    const uint32_t dimensions_192[] = {512};
    operand_192.dimensions = dimensions_192;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_192), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_193{};
    operand_193.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_193.scale = 0.001495834090746939;
    operand_193.zeroPoint = 103;
    operand_193.dimensionCount = 4;
    const uint32_t dimensions_193[] = {0, 3, 3, 512};
    operand_193.dimensions = dimensions_193;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_193), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_194{};
    operand_194.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_194.scale = 0.008620671927928925;
    operand_194.zeroPoint = 120;
    operand_194.dimensionCount = 4;
    const uint32_t dimensions_194[] = {128, 1, 1, 512};
    operand_194.dimensions = dimensions_194;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_194), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_195{};
    operand_195.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_195.scale = 1.289509418711532e-05;
    operand_195.zeroPoint = 0;
    operand_195.dimensionCount = 1;
    const uint32_t dimensions_195[] = {128};
    operand_195.dimensions = dimensions_195;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_195), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_196{};
    operand_196.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_196.scale = 0.004329186864197254;
    operand_196.zeroPoint = 133;
    operand_196.dimensionCount = 4;
    const uint32_t dimensions_196[] = {0, 3, 3, 128};
    operand_196.dimensions = dimensions_196;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_196), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_197{};
    operand_197.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_197.scale = 0.003237461671233177;
    operand_197.zeroPoint = 129;
    operand_197.dimensionCount = 4;
    const uint32_t dimensions_197[] = {768, 1, 1, 128};
    operand_197.dimensions = dimensions_197;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_197), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_198{};
    operand_198.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_198.scale = 1.401557619828964e-05;
    operand_198.zeroPoint = 0;
    operand_198.dimensionCount = 1;
    const uint32_t dimensions_198[] = {768};
    operand_198.dimensions = dimensions_198;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_198), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_199{};
    operand_199.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_199.scale = 0.00272013433277607;
    operand_199.zeroPoint = 0;
    operand_199.dimensionCount = 4;
    const uint32_t dimensions_199[] = {0, 3, 3, 768};
    operand_199.dimensions = dimensions_199;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_199), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_200{};
    operand_200.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_200.scale = 0.001447727903723717;
    operand_200.zeroPoint = 140;
    operand_200.dimensionCount = 4;
    const uint32_t dimensions_200[] = {1, 3, 3, 768};
    operand_200.dimensions = dimensions_200;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_200), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_201{};
    operand_201.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_201.scale = 3.938014287996339e-06;
    operand_201.zeroPoint = 0;
    operand_201.dimensionCount = 1;
    const uint32_t dimensions_201[] = {768};
    operand_201.dimensions = dimensions_201;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_201), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_202{};
    operand_202.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_202.scale = 0.001003918354399502;
    operand_202.zeroPoint = 128;
    operand_202.dimensionCount = 4;
    const uint32_t dimensions_202[] = {0, 3, 3, 768};
    operand_202.dimensions = dimensions_202;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_202), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_203{};
    operand_203.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_203.scale = 0.02241912484169006;
    operand_203.zeroPoint = 132;
    operand_203.dimensionCount = 4;
    const uint32_t dimensions_203[] = {128, 1, 1, 768};
    operand_203.dimensions = dimensions_203;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_203), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_204{};
    operand_204.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_204.scale = 2.250697070849128e-05;
    operand_204.zeroPoint = 0;
    operand_204.dimensionCount = 1;
    const uint32_t dimensions_204[] = {128};
    operand_204.dimensions = dimensions_204;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_204), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_205{};
    operand_205.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_205.scale = 0.004013048950582743;
    operand_205.zeroPoint = 123;
    operand_205.dimensionCount = 4;
    const uint32_t dimensions_205[] = {0, 3, 3, 128};
    operand_205.dimensions = dimensions_205;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_205), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_206{};
    operand_206.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_206.scale = 0.005564078688621521;
    operand_206.zeroPoint = 132;
    operand_206.dimensionCount = 4;
    const uint32_t dimensions_206[] = {0, 3, 3, 128};
    operand_206.dimensions = dimensions_206;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_206), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_207{};
    operand_207.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_207.scale = 0.002945196582004428;
    operand_207.zeroPoint = 130;
    operand_207.dimensionCount = 4;
    const uint32_t dimensions_207[] = {768, 1, 1, 128};
    operand_207.dimensions = dimensions_207;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_207), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_208{};
    operand_208.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_208.scale = 1.638730645936448e-05;
    operand_208.zeroPoint = 0;
    operand_208.dimensionCount = 1;
    const uint32_t dimensions_208[] = {768};
    operand_208.dimensions = dimensions_208;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_208), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_209{};
    operand_209.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_209.scale = 0.002767552156001329;
    operand_209.zeroPoint = 0;
    operand_209.dimensionCount = 4;
    const uint32_t dimensions_209[] = {0, 3, 3, 768};
    operand_209.dimensions = dimensions_209;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_209), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_210{};
    operand_210.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_210.scale = 0.001267897896468639;
    operand_210.zeroPoint = 111;
    operand_210.dimensionCount = 4;
    const uint32_t dimensions_210[] = {1, 3, 3, 768};
    operand_210.dimensions = dimensions_210;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_210), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_211{};
    operand_211.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_211.scale = 3.508973350108135e-06;
    operand_211.zeroPoint = 0;
    operand_211.dimensionCount = 1;
    const uint32_t dimensions_211[] = {768};
    operand_211.dimensions = dimensions_211;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_211), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_212{};
    operand_212.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_212.scale = 0.001003496232442558;
    operand_212.zeroPoint = 103;
    operand_212.dimensionCount = 4;
    const uint32_t dimensions_212[] = {0, 3, 3, 768};
    operand_212.dimensions = dimensions_212;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_212), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_213{};
    operand_213.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_213.scale = 0.04008430987596512;
    operand_213.zeroPoint = 130;
    operand_213.dimensionCount = 4;
    const uint32_t dimensions_213[] = {128, 1, 1, 768};
    operand_213.dimensions = dimensions_213;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_213), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_214{};
    operand_214.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_214.scale = 4.022445500595495e-05;
    operand_214.zeroPoint = 0;
    operand_214.dimensionCount = 1;
    const uint32_t dimensions_214[] = {128};
    operand_214.dimensions = dimensions_214;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_214), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_215{};
    operand_215.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_215.scale = 0.007019979413598776;
    operand_215.zeroPoint = 127;
    operand_215.dimensionCount = 4;
    const uint32_t dimensions_215[] = {0, 3, 3, 128};
    operand_215.dimensions = dimensions_215;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_215), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_216{};
    operand_216.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_216.scale = 0.008132008835673332;
    operand_216.zeroPoint = 113;
    operand_216.dimensionCount = 4;
    const uint32_t dimensions_216[] = {0, 3, 3, 128};
    operand_216.dimensions = dimensions_216;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_216), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_217{};
    operand_217.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_217.scale = 0.002510206308215857;
    operand_217.zeroPoint = 121;
    operand_217.dimensionCount = 4;
    const uint32_t dimensions_217[] = {768, 1, 1, 128};
    operand_217.dimensions = dimensions_217;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_217), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_218{};
    operand_218.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_218.scale = 2.041302104771603e-05;
    operand_218.zeroPoint = 0;
    operand_218.dimensionCount = 1;
    const uint32_t dimensions_218[] = {768};
    operand_218.dimensions = dimensions_218;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_218), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_219{};
    operand_219.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_219.scale = 0.002694383496418595;
    operand_219.zeroPoint = 0;
    operand_219.dimensionCount = 4;
    const uint32_t dimensions_219[] = {0, 3, 3, 768};
    operand_219.dimensions = dimensions_219;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_219), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_220{};
    operand_220.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_220.scale = 0.0008893656777217984;
    operand_220.zeroPoint = 133;
    operand_220.dimensionCount = 4;
    const uint32_t dimensions_220[] = {1, 3, 3, 768};
    operand_220.dimensions = dimensions_220;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_220), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_221{};
    operand_221.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_221.scale = 2.3962923023646e-06;
    operand_221.zeroPoint = 0;
    operand_221.dimensionCount = 1;
    const uint32_t dimensions_221[] = {768};
    operand_221.dimensions = dimensions_221;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_221), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_222{};
    operand_222.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_222.scale = 0.001002407167106867;
    operand_222.zeroPoint = 131;
    operand_222.dimensionCount = 4;
    const uint32_t dimensions_222[] = {0, 3, 3, 768};
    operand_222.dimensions = dimensions_222;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_222), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_223{};
    operand_223.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_223.scale = 0.05506842583417892;
    operand_223.zeroPoint = 153;
    operand_223.dimensionCount = 4;
    const uint32_t dimensions_223[] = {160, 1, 1, 768};
    operand_223.dimensions = dimensions_223;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_223), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_224{};
    operand_224.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_224.scale = 5.520098784472793e-05;
    operand_224.zeroPoint = 0;
    operand_224.dimensionCount = 1;
    const uint32_t dimensions_224[] = {160};
    operand_224.dimensions = dimensions_224;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_224), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_225{};
    operand_225.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_225.scale = 0.005563139915466309;
    operand_225.zeroPoint = 126;
    operand_225.dimensionCount = 4;
    const uint32_t dimensions_225[] = {0, 3, 3, 160};
    operand_225.dimensions = dimensions_225;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_225), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_226{};
    operand_226.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_226.scale = 0.02526126243174076;
    operand_226.zeroPoint = 112;
    operand_226.dimensionCount = 4;
    const uint32_t dimensions_226[] = {160, 1, 1, 160};
    operand_226.dimensions = dimensions_226;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_226), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_227{};
    operand_227.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_227.scale = 0.0001405319344485179;
    operand_227.zeroPoint = 0;
    operand_227.dimensionCount = 1;
    const uint32_t dimensions_227[] = {160};
    operand_227.dimensions = dimensions_227;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_227), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_228{};
    operand_228.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_228.scale = 0.04058342799544334;
    operand_228.zeroPoint = 0;
    operand_228.dimensionCount = 4;
    const uint32_t dimensions_228[] = {0, 3, 3, 160};
    operand_228.dimensions = dimensions_228;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_228), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_229{};
    operand_229.type = ANEURALNETWORKS_INT32;
    operand_229.scale = 0;
    operand_229.zeroPoint = 0;
    operand_229.dimensionCount = 0;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_229), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_230{};
    operand_230.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_230.scale = 0.04058342799544334;
    operand_230.zeroPoint = 0;
    operand_230.dimensionCount = 4;
    const uint32_t dimensions_230[] = {0, 1, 1, 160};
    operand_230.dimensions = dimensions_230;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_230), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_231{};
    operand_231.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_231.scale = 0.005672636907547712;
    operand_231.zeroPoint = 136;
    operand_231.dimensionCount = 2;
    const uint32_t dimensions_231[] = {81, 160};
    operand_231.dimensions = dimensions_231;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_231), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_232{};
    operand_232.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_232.scale = 0.0002302150533068925;
    operand_232.zeroPoint = 0;
    operand_232.dimensionCount = 1;
    const uint32_t dimensions_232[] = {81};
    operand_232.dimensions = dimensions_232;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_232), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_233{};
    operand_233.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_233.scale = 0.08092430979013443;
    operand_233.zeroPoint = 80;
    operand_233.dimensionCount = 2;
    const uint32_t dimensions_233[] = {0, 81};
    operand_233.dimensions = dimensions_233;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_233), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_234{};
    operand_234.type = ANEURALNETWORKS_FLOAT32;
    operand_234.scale = 0;
    operand_234.zeroPoint = 0;
    operand_234.dimensionCount = 0;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_234), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_235{};
    operand_235.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_235.scale = 0.00390625;
    operand_235.zeroPoint = 0;
    operand_235.dimensionCount = 2;
    const uint32_t dimensions_235[] = {0, 81};
    operand_235.dimensions = dimensions_235;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_235), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_236{};
    operand_236.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_236.scale = 0.0006408203043974936;
    operand_236.zeroPoint = 139;
    operand_236.dimensionCount = 2;
    const uint32_t dimensions_236[] = {324, 160};
    operand_236.dimensions = dimensions_236;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_236), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_237{};
    operand_237.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_237.scale = 2.600668449304067e-05;
    operand_237.zeroPoint = 0;
    operand_237.dimensionCount = 1;
    const uint32_t dimensions_237[] = {324};
    operand_237.dimensions = dimensions_237;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_237), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_238{};
    operand_238.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_238.scale = 0.004951907321810722;
    operand_238.zeroPoint = 131;
    operand_238.dimensionCount = 2;
    const uint32_t dimensions_238[] = {0, 324};
    operand_238.dimensions = dimensions_238;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_238), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_239{};
    operand_239.type = ANEURALNETWORKS_TENSOR_QUANT16_ASYMM;
    operand_239.scale = 0.125;
    operand_239.zeroPoint = 0;
    operand_239.dimensionCount = 2;
    const uint32_t dimensions_239[] = {0, 324};
    operand_239.dimensions = dimensions_239;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_239), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_240{};
    operand_240.type = ANEURALNETWORKS_FLOAT32;
    operand_240.scale = 0;
    operand_240.zeroPoint = 0;
    operand_240.dimensionCount = 0;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_240), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_241{};
    operand_241.type = ANEURALNETWORKS_FLOAT32;
    operand_241.scale = 0;
    operand_241.zeroPoint = 0;
    operand_241.dimensionCount = 0;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_241), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_242{};
    operand_242.type = ANEURALNETWORKS_FLOAT32;
    operand_242.scale = 0;
    operand_242.zeroPoint = 0;
    operand_242.dimensionCount = 0;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_242), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_243{};
    operand_243.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_243.scale = 0.00390625;
    operand_243.zeroPoint = 0;
    operand_243.dimensionCount = 1;
    const uint32_t dimensions_243[] = {0};
    operand_243.dimensions = dimensions_243;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_243), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_244{};
    operand_244.type = ANEURALNETWORKS_TENSOR_QUANT16_ASYMM;
    operand_244.scale = 0.125;
    operand_244.zeroPoint = 0;
    operand_244.dimensionCount = 2;
    const uint32_t dimensions_244[] = {0, 4};
    operand_244.dimensions = dimensions_244;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_244), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_245{};
    operand_245.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_245.scale = 0;
    operand_245.zeroPoint = 0;
    operand_245.dimensionCount = 1;
    const uint32_t dimensions_245[] = {0};
    operand_245.dimensions = dimensions_245;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_245), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_246{};
    operand_246.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_246.scale = 0;
    operand_246.zeroPoint = 0;
    operand_246.dimensionCount = 1;
    const uint32_t dimensions_246[] = {0};
    operand_246.dimensions = dimensions_246;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_246), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_247{};
    operand_247.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_247.scale = 0.009006229229271412;
    operand_247.zeroPoint = 119;
    operand_247.dimensionCount = 4;
    const uint32_t dimensions_247[] = {0, 6, 6, 128};
    operand_247.dimensions = dimensions_247;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_247), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_248{};
    operand_248.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_248.scale = 0.002211635699495673;
    operand_248.zeroPoint = 132;
    operand_248.dimensionCount = 4;
    const uint32_t dimensions_248[] = {512, 1, 1, 128};
    operand_248.dimensions = dimensions_248;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_248), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_249{};
    operand_249.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_249.scale = 1.991849785554223e-05;
    operand_249.zeroPoint = 0;
    operand_249.dimensionCount = 1;
    const uint32_t dimensions_249[] = {512};
    operand_249.dimensions = dimensions_249;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_249), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_250{};
    operand_250.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_250.scale = 0.002592636970803142;
    operand_250.zeroPoint = 0;
    operand_250.dimensionCount = 4;
    const uint32_t dimensions_250[] = {0, 6, 6, 512};
    operand_250.dimensions = dimensions_250;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_250), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_251{};
    operand_251.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_251.scale = 0.001000639051198959;
    operand_251.zeroPoint = 148;
    operand_251.dimensionCount = 4;
    const uint32_t dimensions_251[] = {1, 3, 3, 512};
    operand_251.dimensions = dimensions_251;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_251), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_252{};
    operand_252.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_252.scale = 2.5942936190404e-06;
    operand_252.zeroPoint = 0;
    operand_252.dimensionCount = 1;
    const uint32_t dimensions_252[] = {512};
    operand_252.dimensions = dimensions_252;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_252), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_253{};
    operand_253.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_253.scale = 0.001002595527097583;
    operand_253.zeroPoint = 116;
    operand_253.dimensionCount = 4;
    const uint32_t dimensions_253[] = {0, 6, 6, 512};
    operand_253.dimensions = dimensions_253;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_253), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_254{};
    operand_254.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_254.scale = 0.01961961947381496;
    operand_254.zeroPoint = 135;
    operand_254.dimensionCount = 4;
    const uint32_t dimensions_254[] = {128, 1, 1, 512};
    operand_254.dimensions = dimensions_254;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_254), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_255{};
    operand_255.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_255.scale = 1.967054413398728e-05;
    operand_255.zeroPoint = 0;
    operand_255.dimensionCount = 1;
    const uint32_t dimensions_255[] = {128};
    operand_255.dimensions = dimensions_255;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_255), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_256{};
    operand_256.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_256.scale = 0.003791325259953737;
    operand_256.zeroPoint = 133;
    operand_256.dimensionCount = 4;
    const uint32_t dimensions_256[] = {0, 6, 6, 128};
    operand_256.dimensions = dimensions_256;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_256), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_257{};
    operand_257.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_257.scale = 0.009337191469967365;
    operand_257.zeroPoint = 121;
    operand_257.dimensionCount = 4;
    const uint32_t dimensions_257[] = {0, 6, 6, 128};
    operand_257.dimensions = dimensions_257;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_257), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_258{};
    operand_258.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_258.scale = 0.002133074915036559;
    operand_258.zeroPoint = 128;
    operand_258.dimensionCount = 4;
    const uint32_t dimensions_258[] = {768, 1, 1, 128};
    operand_258.dimensions = dimensions_258;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_258), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_259{};
    operand_259.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_259.scale = 1.991692988667637e-05;
    operand_259.zeroPoint = 0;
    operand_259.dimensionCount = 1;
    const uint32_t dimensions_259[] = {768};
    operand_259.dimensions = dimensions_259;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_259), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_260{};
    operand_260.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_260.scale = 0.002098787110298872;
    operand_260.zeroPoint = 0;
    operand_260.dimensionCount = 4;
    const uint32_t dimensions_260[] = {0, 6, 6, 768};
    operand_260.dimensions = dimensions_260;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_260), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_261{};
    operand_261.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_261.scale = 0.0008608275675214827;
    operand_261.zeroPoint = 124;
    operand_261.dimensionCount = 4;
    const uint32_t dimensions_261[] = {1, 3, 3, 768};
    operand_261.dimensions = dimensions_261;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_261), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_262{};
    operand_262.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_262.scale = 1.806693830985751e-06;
    operand_262.zeroPoint = 0;
    operand_262.dimensionCount = 1;
    const uint32_t dimensions_262[] = {768};
    operand_262.dimensions = dimensions_262;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_262), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_263{};
    operand_263.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_263.scale = 0.001001805765554309;
    operand_263.zeroPoint = 150;
    operand_263.dimensionCount = 4;
    const uint32_t dimensions_263[] = {0, 6, 6, 768};
    operand_263.dimensions = dimensions_263;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_263), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_264{};
    operand_264.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_264.scale = 0.0244825966656208;
    operand_264.zeroPoint = 125;
    operand_264.dimensionCount = 4;
    const uint32_t dimensions_264[] = {128, 1, 1, 768};
    operand_264.dimensions = dimensions_264;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_264), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_265{};
    operand_265.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_265.scale = 2.452680564601906e-05;
    operand_265.zeroPoint = 0;
    operand_265.dimensionCount = 1;
    const uint32_t dimensions_265[] = {128};
    operand_265.dimensions = dimensions_265;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_265), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_266{};
    operand_266.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_266.scale = 0.003958381246775389;
    operand_266.zeroPoint = 126;
    operand_266.dimensionCount = 4;
    const uint32_t dimensions_266[] = {0, 6, 6, 128};
    operand_266.dimensions = dimensions_266;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_266), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_267{};
    operand_267.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_267.scale = 0.009366916492581367;
    operand_267.zeroPoint = 121;
    operand_267.dimensionCount = 4;
    const uint32_t dimensions_267[] = {0, 6, 6, 128};
    operand_267.dimensions = dimensions_267;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_267), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_268{};
    operand_268.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_268.scale = 0.002321642125025392;
    operand_268.zeroPoint = 121;
    operand_268.dimensionCount = 4;
    const uint32_t dimensions_268[] = {768, 1, 1, 128};
    operand_268.dimensions = dimensions_268;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_268), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_269{};
    operand_269.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_269.scale = 2.17466258618515e-05;
    operand_269.zeroPoint = 0;
    operand_269.dimensionCount = 1;
    const uint32_t dimensions_269[] = {768};
    operand_269.dimensions = dimensions_269;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_269), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_270{};
    operand_270.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_270.scale = 0.002672255504876375;
    operand_270.zeroPoint = 0;
    operand_270.dimensionCount = 4;
    const uint32_t dimensions_270[] = {0, 6, 6, 768};
    operand_270.dimensions = dimensions_270;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_270), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_271{};
    operand_271.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_271.scale = 0.0008156994008459151;
    operand_271.zeroPoint = 131;
    operand_271.dimensionCount = 4;
    const uint32_t dimensions_271[] = {1, 3, 3, 768};
    operand_271.dimensions = dimensions_271;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_271), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_272{};
    operand_272.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_272.scale = 2.179757075282396e-06;
    operand_272.zeroPoint = 0;
    operand_272.dimensionCount = 1;
    const uint32_t dimensions_272[] = {768};
    operand_272.dimensions = dimensions_272;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_272), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_273{};
    operand_273.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_273.scale = 0.00100218434818089;
    operand_273.zeroPoint = 104;
    operand_273.dimensionCount = 4;
    const uint32_t dimensions_273[] = {0, 6, 6, 768};
    operand_273.dimensions = dimensions_273;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_273), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_274{};
    operand_274.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_274.scale = 0.02847485058009624;
    operand_274.zeroPoint = 121;
    operand_274.dimensionCount = 4;
    const uint32_t dimensions_274[] = {128, 1, 1, 768};
    operand_274.dimensions = dimensions_274;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_274), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_275{};
    operand_275.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_275.scale = 2.853704972949345e-05;
    operand_275.zeroPoint = 0;
    operand_275.dimensionCount = 1;
    const uint32_t dimensions_275[] = {128};
    operand_275.dimensions = dimensions_275;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_275), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_276{};
    operand_276.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_276.scale = 0.005113502498716116;
    operand_276.zeroPoint = 134;
    operand_276.dimensionCount = 4;
    const uint32_t dimensions_276[] = {0, 6, 6, 128};
    operand_276.dimensions = dimensions_276;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_276), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_277{};
    operand_277.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_277.scale = 0.009635390713810921;
    operand_277.zeroPoint = 126;
    operand_277.dimensionCount = 4;
    const uint32_t dimensions_277[] = {0, 6, 6, 128};
    operand_277.dimensions = dimensions_277;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_277), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_278{};
    operand_278.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_278.scale = 0.002073407173156738;
    operand_278.zeroPoint = 138;
    operand_278.dimensionCount = 4;
    const uint32_t dimensions_278[] = {768, 1, 1, 128};
    operand_278.dimensions = dimensions_278;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_278), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_279{};
    operand_279.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_279.scale = 1.997808794840239e-05;
    operand_279.zeroPoint = 0;
    operand_279.dimensionCount = 1;
    const uint32_t dimensions_279[] = {768};
    operand_279.dimensions = dimensions_279;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_279), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_280{};
    operand_280.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_280.scale = 0.00225812871940434;
    operand_280.zeroPoint = 0;
    operand_280.dimensionCount = 4;
    const uint32_t dimensions_280[] = {0, 6, 6, 768};
    operand_280.dimensions = dimensions_280;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_280), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_281{};
    operand_281.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_281.scale = 0.0009067427599802613;
    operand_281.zeroPoint = 116;
    operand_281.dimensionCount = 4;
    const uint32_t dimensions_281[] = {1, 3, 3, 768};
    operand_281.dimensions = dimensions_281;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_281), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_282{};
    operand_282.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_282.scale = 2.047542011496262e-06;
    operand_282.zeroPoint = 0;
    operand_282.dimensionCount = 1;
    const uint32_t dimensions_282[] = {768};
    operand_282.dimensions = dimensions_282;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_282), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_283{};
    operand_283.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_283.scale = 0.001002039294689894;
    operand_283.zeroPoint = 121;
    operand_283.dimensionCount = 4;
    const uint32_t dimensions_283[] = {0, 6, 6, 768};
    operand_283.dimensions = dimensions_283;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_283), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_284{};
    operand_284.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_284.scale = 0.0345500223338604;
    operand_284.zeroPoint = 134;
    operand_284.dimensionCount = 4;
    const uint32_t dimensions_284[] = {128, 1, 1, 768};
    operand_284.dimensions = dimensions_284;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_284), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_285{};
    operand_285.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_285.scale = 3.462047970970161e-05;
    operand_285.zeroPoint = 0;
    operand_285.dimensionCount = 1;
    const uint32_t dimensions_285[] = {128};
    operand_285.dimensions = dimensions_285;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_285), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_286{};
    operand_286.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_286.scale = 0.005219598766416311;
    operand_286.zeroPoint = 129;
    operand_286.dimensionCount = 4;
    const uint32_t dimensions_286[] = {0, 6, 6, 128};
    operand_286.dimensions = dimensions_286;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_286), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_287{};
    operand_287.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_287.scale = 0.01011695526540279;
    operand_287.zeroPoint = 125;
    operand_287.dimensionCount = 4;
    const uint32_t dimensions_287[] = {0, 6, 6, 128};
    operand_287.dimensions = dimensions_287;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_287), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_288{};
    operand_288.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_288.scale = 0.002151809399947524;
    operand_288.zeroPoint = 134;
    operand_288.dimensionCount = 4;
    const uint32_t dimensions_288[] = {384, 1, 1, 128};
    operand_288.dimensions = dimensions_288;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_288), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_289{};
    operand_289.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_289.scale = 2.176975976908579e-05;
    operand_289.zeroPoint = 0;
    operand_289.dimensionCount = 1;
    const uint32_t dimensions_289[] = {384};
    operand_289.dimensions = dimensions_289;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_289), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_290{};
    operand_290.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_290.scale = 0.003372935345396399;
    operand_290.zeroPoint = 0;
    operand_290.dimensionCount = 4;
    const uint32_t dimensions_290[] = {0, 6, 6, 384};
    operand_290.dimensions = dimensions_290;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_290), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_291{};
    operand_291.type = ANEURALNETWORKS_FLOAT32;
    operand_291.scale = 0;
    operand_291.zeroPoint = 0;
    operand_291.dimensionCount = 0;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_291), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_292{};
    operand_292.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_292.scale = 0.003372935345396399;
    operand_292.zeroPoint = 0;
    operand_292.dimensionCount = 4;
    const uint32_t dimensions_292[] = {0, 12, 12, 384};
    operand_292.dimensions = dimensions_292;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_292), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_293{};
    operand_293.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_293.scale = 0.001229611807502806;
    operand_293.zeroPoint = 134;
    operand_293.dimensionCount = 4;
    const uint32_t dimensions_293[] = {1, 3, 3, 384};
    operand_293.dimensions = dimensions_293;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_293), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_294{};
    operand_294.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_294.scale = 4.147401341469958e-06;
    operand_294.zeroPoint = 0;
    operand_294.dimensionCount = 1;
    const uint32_t dimensions_294[] = {384};
    operand_294.dimensions = dimensions_294;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_294), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_295{};
    operand_295.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_295.scale = 0.001418625121004879;
    operand_295.zeroPoint = 129;
    operand_295.dimensionCount = 4;
    const uint32_t dimensions_295[] = {0, 12, 12, 384};
    operand_295.dimensions = dimensions_295;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_295), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_296{};
    operand_296.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_296.scale = 0.06397756934165955;
    operand_296.zeroPoint = 123;
    operand_296.dimensionCount = 4;
    const uint32_t dimensions_296[] = {64, 1, 1, 384};
    operand_296.dimensions = dimensions_296;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_296), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_297{};
    operand_297.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_297.scale = 9.076018613995984e-05;
    operand_297.zeroPoint = 0;
    operand_297.dimensionCount = 1;
    const uint32_t dimensions_297[] = {64};
    operand_297.dimensions = dimensions_297;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_297), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_298{};
    operand_298.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_298.scale = 0.04541563242673874;
    operand_298.zeroPoint = 145;
    operand_298.dimensionCount = 4;
    const uint32_t dimensions_298[] = {0, 12, 12, 64};
    operand_298.dimensions = dimensions_298;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_298), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_299{};
    operand_299.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_299.scale = 0.003162507666274905;
    operand_299.zeroPoint = 127;
    operand_299.dimensionCount = 4;
    const uint32_t dimensions_299[] = {81, 1, 1, 64};
    operand_299.dimensions = dimensions_299;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_299), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_300{};
    operand_300.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_300.scale = 0.000143627286888659;
    operand_300.zeroPoint = 0;
    operand_300.dimensionCount = 1;
    const uint32_t dimensions_300[] = {81};
    operand_300.dimensions = dimensions_300;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_300), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_301{};
    operand_301.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
    operand_301.scale = 0.08356435596942902;
    operand_301.zeroPoint = 135;
    operand_301.dimensionCount = 4;
    const uint32_t dimensions_301[] = {0, 12, 12, 81};
    operand_301.dimensions = dimensions_301;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_301), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_302{};
    operand_302.type = ANEURALNETWORKS_TENSOR_FLOAT32;
    operand_302.scale = 0;
    operand_302.zeroPoint = 0;
    operand_302.dimensionCount = 4;
    const uint32_t dimensions_302[] = {0, 12, 12, 81};
    operand_302.dimensions = dimensions_302;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_302), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_303{};
    operand_303.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_303.scale = 0;
    operand_303.zeroPoint = 0;
    operand_303.dimensionCount = 1;
    const uint32_t dimensions_303[] = {4};
    operand_303.dimensions = dimensions_303;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_303), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_304{};
    operand_304.type = ANEURALNETWORKS_TENSOR_FLOAT32;
    operand_304.scale = 0;
    operand_304.zeroPoint = 0;
    operand_304.dimensionCount = 4;
    const uint32_t dimensions_304[] = {0, 81, 12, 12};
    operand_304.dimensions = dimensions_304;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_304), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_305{};
    operand_305.type = ANEURALNETWORKS_TENSOR_FLOAT32;
    operand_305.scale = 0;
    operand_305.zeroPoint = 0;
    operand_305.dimensionCount = 4;
    const uint32_t dimensions_305[] = {0, 81, 12, 12};
    operand_305.dimensions = dimensions_305;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_305), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_306{};
    operand_306.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_306.scale = 0;
    operand_306.zeroPoint = 0;
    operand_306.dimensionCount = 1;
    const uint32_t dimensions_306[] = {2};
    operand_306.dimensions = dimensions_306;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_306), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_307{};
    operand_307.type = ANEURALNETWORKS_TENSOR_INT32;
    operand_307.scale = 0;
    operand_307.zeroPoint = 0;
    operand_307.dimensionCount = 1;
    const uint32_t dimensions_307[] = {2};
    operand_307.dimensions = dimensions_307;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_307), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_308{};
    operand_308.type = ANEURALNETWORKS_TENSOR_FLOAT32;
    operand_308.scale = 0;
    operand_308.zeroPoint = 0;
    operand_308.dimensionCount = 2;
    const uint32_t dimensions_308[] = {1, 1};
    operand_308.dimensions = dimensions_308;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_308), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType operand_309{};
    operand_309.type = ANEURALNETWORKS_TENSOR_FLOAT32;
    operand_309.scale = 0;
    operand_309.zeroPoint = 0;
    operand_309.dimensionCount = 1;
    const uint32_t dimensions_309[] = {0};
    operand_309.dimensions = dimensions_309;
    ASSERT_EQ(ANeuralNetworksModel_addOperand(model, &operand_309), ANEURALNETWORKS_NO_ERROR);
#include "generated/maskrcnn/maskrcnn2go_quantized_const_data.cpp"
    const uint32_t input_0[] = {2, 6};
    const uint32_t output_0[] = {7};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_TRANSPOSE, 2, input_0, 1,
                                                output_0),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_1[] = {7};
    const uint32_t output_1[] = {8};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_QUANTIZE, 1, input_1, 1,
                                                output_1),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_2[] = {8, 9, 10, 11, 11, 11, 11, 12, 12, 11, 0};
    const uint32_t output_2[] = {13};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_2, 1,
                                                output_2),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_3[] = {13, 14, 15, 16, 16, 16, 16, 11, 11, 11, 0};
    const uint32_t output_3[] = {17};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_3, 1,
                                                output_3),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_4[] = {17, 18, 19, 11, 11, 11, 11, 11, 11, 11, 16, 0};
    const uint32_t output_4[] = {20};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_DEPTHWISE_CONV_2D, 12,
                                                input_4, 1, output_4),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_5[] = {20, 21, 22, 16, 16, 16, 16, 11, 11, 16, 0};
    const uint32_t output_5[] = {23};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_5, 1,
                                                output_5),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_6[] = {23, 13, 16};
    const uint32_t output_6[] = {24};
    ASSERT_EQ(
            ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_ADD, 3, input_6, 1, output_6),
            ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_7[] = {24, 25, 26, 16, 16, 16, 16, 11, 11, 11, 0};
    const uint32_t output_7[] = {27};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_7, 1,
                                                output_7),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_8[] = {27, 28, 29, 11, 11, 11, 11, 12, 12, 11, 16, 0};
    const uint32_t output_8[] = {30};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_DEPTHWISE_CONV_2D, 12,
                                                input_8, 1, output_8),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_9[] = {30, 31, 32, 16, 16, 16, 16, 11, 11, 16, 0};
    const uint32_t output_9[] = {33};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_9, 1,
                                                output_9),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_10[] = {33, 34, 35, 16, 16, 16, 16, 11, 11, 11, 0};
    const uint32_t output_10[] = {36};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_10, 1,
                                                output_10),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_11[] = {36, 37, 38, 11, 11, 11, 11, 11, 11, 11, 16, 0};
    const uint32_t output_11[] = {39};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_DEPTHWISE_CONV_2D, 12,
                                                input_11, 1, output_11),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_12[] = {39, 40, 41, 16, 16, 16, 16, 11, 11, 16, 0};
    const uint32_t output_12[] = {42};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_12, 1,
                                                output_12),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_13[] = {42, 33, 16};
    const uint32_t output_13[] = {43};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_ADD, 3, input_13, 1,
                                                output_13),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_14[] = {43, 44, 45, 16, 16, 16, 16, 11, 11, 11, 0};
    const uint32_t output_14[] = {46};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_14, 1,
                                                output_14),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_15[] = {46, 47, 48, 11, 11, 11, 11, 12, 12, 11, 16, 0};
    const uint32_t output_15[] = {49};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_DEPTHWISE_CONV_2D, 12,
                                                input_15, 1, output_15),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_16[] = {49, 50, 51, 16, 16, 16, 16, 11, 11, 16, 0};
    const uint32_t output_16[] = {52};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_16, 1,
                                                output_16),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_17[] = {52, 53, 54, 16, 16, 16, 16, 11, 11, 11, 0};
    const uint32_t output_17[] = {55};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_17, 1,
                                                output_17),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_18[] = {55, 56, 57, 11, 11, 11, 11, 11, 11, 11, 16, 0};
    const uint32_t output_18[] = {58};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_DEPTHWISE_CONV_2D, 12,
                                                input_18, 1, output_18),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_19[] = {58, 59, 60, 16, 16, 16, 16, 11, 11, 16, 0};
    const uint32_t output_19[] = {61};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_19, 1,
                                                output_19),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_20[] = {61, 52, 16};
    const uint32_t output_20[] = {62};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_ADD, 3, input_20, 1,
                                                output_20),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_21[] = {62, 63, 64, 16, 16, 16, 16, 11, 11, 11, 0};
    const uint32_t output_21[] = {65};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_21, 1,
                                                output_21),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_22[] = {65, 66, 67, 11, 11, 11, 11, 11, 11, 11, 16, 0};
    const uint32_t output_22[] = {68};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_DEPTHWISE_CONV_2D, 12,
                                                input_22, 1, output_22),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_23[] = {68, 69, 70, 16, 16, 16, 16, 11, 11, 16, 0};
    const uint32_t output_23[] = {71};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_23, 1,
                                                output_23),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_24[] = {71, 62, 16};
    const uint32_t output_24[] = {72};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_ADD, 3, input_24, 1,
                                                output_24),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_25[] = {72, 73, 74, 16, 16, 16, 16, 11, 11, 11, 0};
    const uint32_t output_25[] = {75};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_25, 1,
                                                output_25),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_26[] = {75, 76, 77, 11, 11, 11, 11, 12, 12, 11, 16, 0};
    const uint32_t output_26[] = {78};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_DEPTHWISE_CONV_2D, 12,
                                                input_26, 1, output_26),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_27[] = {78, 79, 80, 16, 16, 16, 16, 11, 11, 16, 0};
    const uint32_t output_27[] = {81};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_27, 1,
                                                output_27),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_28[] = {81, 82, 83, 16, 16, 16, 16, 11, 11, 11, 0};
    const uint32_t output_28[] = {84};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_28, 1,
                                                output_28),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_29[] = {84, 85, 86, 11, 11, 11, 11, 11, 11, 11, 16, 0};
    const uint32_t output_29[] = {87};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_DEPTHWISE_CONV_2D, 12,
                                                input_29, 1, output_29),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_30[] = {87, 88, 89, 16, 16, 16, 16, 11, 11, 16, 0};
    const uint32_t output_30[] = {90};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_30, 1,
                                                output_30),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_31[] = {90, 81, 16};
    const uint32_t output_31[] = {91};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_ADD, 3, input_31, 1,
                                                output_31),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_32[] = {91, 92, 93, 16, 16, 16, 16, 11, 11, 11, 0};
    const uint32_t output_32[] = {94};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_32, 1,
                                                output_32),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_33[] = {94, 95, 96, 11, 11, 11, 11, 11, 11, 11, 16, 0};
    const uint32_t output_33[] = {97};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_DEPTHWISE_CONV_2D, 12,
                                                input_33, 1, output_33),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_34[] = {97, 98, 99, 16, 16, 16, 16, 11, 11, 16, 0};
    const uint32_t output_34[] = {100};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_34, 1,
                                                output_34),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_35[] = {100, 91, 16};
    const uint32_t output_35[] = {101};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_ADD, 3, input_35, 1,
                                                output_35),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_36[] = {101, 102, 103, 16, 16, 16, 16, 11, 11, 11, 0};
    const uint32_t output_36[] = {104};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_36, 1,
                                                output_36),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_37[] = {104, 105, 106, 11, 11, 11, 11, 11, 11, 11, 16, 0};
    const uint32_t output_37[] = {107};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_DEPTHWISE_CONV_2D, 12,
                                                input_37, 1, output_37),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_38[] = {107, 108, 109, 16, 16, 16, 16, 11, 11, 16, 0};
    const uint32_t output_38[] = {110};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_38, 1,
                                                output_38),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_39[] = {110, 101, 16};
    const uint32_t output_39[] = {111};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_ADD, 3, input_39, 1,
                                                output_39),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_40[] = {111, 112, 113, 16, 16, 16, 16, 11, 11, 11, 0};
    const uint32_t output_40[] = {114};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_40, 1,
                                                output_40),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_41[] = {114, 115, 116, 11, 11, 11, 11, 11, 11, 11, 16, 0};
    const uint32_t output_41[] = {117};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_DEPTHWISE_CONV_2D, 12,
                                                input_41, 1, output_41),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_42[] = {117, 118, 119, 16, 16, 16, 16, 11, 11, 16, 0};
    const uint32_t output_42[] = {120};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_42, 1,
                                                output_42),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_43[] = {120, 121, 122, 16, 16, 16, 16, 11, 11, 11, 0};
    const uint32_t output_43[] = {123};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_43, 1,
                                                output_43),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_44[] = {123, 124, 125, 11, 11, 11, 11, 11, 11, 11, 16, 0};
    const uint32_t output_44[] = {126};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_DEPTHWISE_CONV_2D, 12,
                                                input_44, 1, output_44),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_45[] = {126, 127, 128, 16, 16, 16, 16, 11, 11, 16, 0};
    const uint32_t output_45[] = {129};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_45, 1,
                                                output_45),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_46[] = {129, 120, 16};
    const uint32_t output_46[] = {130};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_ADD, 3, input_46, 1,
                                                output_46),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_47[] = {130, 131, 132, 16, 16, 16, 16, 11, 11, 11, 0};
    const uint32_t output_47[] = {133};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_47, 1,
                                                output_47),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_48[] = {133, 134, 135, 11, 11, 11, 11, 11, 11, 11, 16, 0};
    const uint32_t output_48[] = {136};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_DEPTHWISE_CONV_2D, 12,
                                                input_48, 1, output_48),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_49[] = {136, 137, 138, 16, 16, 16, 16, 11, 11, 16, 0};
    const uint32_t output_49[] = {139};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_49, 1,
                                                output_49),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_50[] = {139, 130, 16};
    const uint32_t output_50[] = {140};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_ADD, 3, input_50, 1,
                                                output_50),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_51[] = {140, 141, 142, 16, 16, 16, 16, 11, 11, 11, 0};
    const uint32_t output_51[] = {143};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_51, 1,
                                                output_51),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_52[] = {143, 144, 145, 11, 11, 11, 11, 11, 11, 11, 16, 0};
    const uint32_t output_52[] = {146};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_DEPTHWISE_CONV_2D, 12,
                                                input_52, 1, output_52),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_53[] = {146, 147, 148, 16, 16, 16, 16, 11, 11, 16, 0};
    const uint32_t output_53[] = {149};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_53, 1,
                                                output_53),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_54[] = {149, 140, 16};
    const uint32_t output_54[] = {150};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_ADD, 3, input_54, 1,
                                                output_54),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_55[] = {150, 151, 152, 16, 16, 16, 16, 11, 11, 11, 0};
    const uint32_t output_55[] = {153};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_55, 1,
                                                output_55),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_56[] = {153, 154, 155, 11, 11, 11, 11, 11, 11, 11, 16, 0};
    const uint32_t output_56[] = {156};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_DEPTHWISE_CONV_2D, 12,
                                                input_56, 1, output_56),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_57[] = {156, 157, 158, 16, 16, 16, 16, 11, 11, 16, 0};
    const uint32_t output_57[] = {159};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_57, 1,
                                                output_57),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_58[] = {159, 150, 16};
    const uint32_t output_58[] = {160};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_ADD, 3, input_58, 1,
                                                output_58),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_59[] = {160, 161, 162, 16, 16, 16, 16, 11, 11, 11, 0};
    const uint32_t output_59[] = {163};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_59, 1,
                                                output_59),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_60[] = {163, 164, 165, 11, 11, 11, 11, 11, 11, 11, 16, 0};
    const uint32_t output_60[] = {166};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_DEPTHWISE_CONV_2D, 12,
                                                input_60, 1, output_60),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_61[] = {166, 167, 168, 16, 16, 16, 16, 11, 11, 16, 0};
    const uint32_t output_61[] = {169};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_61, 1,
                                                output_61),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_62[] = {169, 160, 16};
    const uint32_t output_62[] = {170};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_ADD, 3, input_62, 1,
                                                output_62),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_63[] = {170, 171, 172, 16, 16, 16, 16, 11, 11, 16, 0};
    const uint32_t output_63[] = {173};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_63, 1,
                                                output_63),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_64[] = {170, 174, 175, 16, 16, 16, 16, 11, 11, 16, 0};
    const uint32_t output_64[] = {176};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_64, 1,
                                                output_64),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_65[] = {173, 176, 177, 5, 178, 178, 179, 180, 181, 182, 0};
    const uint32_t output_65[] = {183, 184, 185};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_GENERATE_PROPOSALS, 11,
                                                input_65, 3, output_65),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_66[] = {140, 184, 185, 186, 186, 178, 178, 16, 16, 0};
    const uint32_t output_66[] = {187};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_ROI_ALIGN, 10, input_66, 1,
                                                output_66),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_67[] = {187, 188, 189, 16, 16, 16, 16, 11, 11, 11, 0};
    const uint32_t output_67[] = {190};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_67, 1,
                                                output_67),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_68[] = {190, 191, 192, 11, 11, 11, 11, 12, 12, 11, 16, 0};
    const uint32_t output_68[] = {193};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_DEPTHWISE_CONV_2D, 12,
                                                input_68, 1, output_68),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_69[] = {193, 194, 195, 16, 16, 16, 16, 11, 11, 16, 0};
    const uint32_t output_69[] = {196};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_69, 1,
                                                output_69),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_70[] = {196, 197, 198, 16, 16, 16, 16, 11, 11, 11, 0};
    const uint32_t output_70[] = {199};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_70, 1,
                                                output_70),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_71[] = {199, 200, 201, 11, 11, 11, 11, 11, 11, 11, 16, 0};
    const uint32_t output_71[] = {202};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_DEPTHWISE_CONV_2D, 12,
                                                input_71, 1, output_71),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_72[] = {202, 203, 204, 16, 16, 16, 16, 11, 11, 16, 0};
    const uint32_t output_72[] = {205};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_72, 1,
                                                output_72),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_73[] = {205, 196, 16};
    const uint32_t output_73[] = {206};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_ADD, 3, input_73, 1,
                                                output_73),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_74[] = {206, 207, 208, 16, 16, 16, 16, 11, 11, 11, 0};
    const uint32_t output_74[] = {209};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_74, 1,
                                                output_74),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_75[] = {209, 210, 211, 11, 11, 11, 11, 11, 11, 11, 16, 0};
    const uint32_t output_75[] = {212};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_DEPTHWISE_CONV_2D, 12,
                                                input_75, 1, output_75),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_76[] = {212, 213, 214, 16, 16, 16, 16, 11, 11, 16, 0};
    const uint32_t output_76[] = {215};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_76, 1,
                                                output_76),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_77[] = {215, 206, 16};
    const uint32_t output_77[] = {216};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_ADD, 3, input_77, 1,
                                                output_77),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_78[] = {216, 217, 218, 16, 16, 16, 16, 11, 11, 11, 0};
    const uint32_t output_78[] = {219};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_78, 1,
                                                output_78),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_79[] = {219, 220, 221, 11, 11, 11, 11, 11, 11, 11, 16, 0};
    const uint32_t output_79[] = {222};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_DEPTHWISE_CONV_2D, 12,
                                                input_79, 1, output_79),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_80[] = {222, 223, 224, 16, 16, 16, 16, 11, 11, 16, 0};
    const uint32_t output_80[] = {225};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_80, 1,
                                                output_80),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_81[] = {225, 226, 227, 16, 16, 16, 16, 11, 11, 11, 0};
    const uint32_t output_81[] = {228};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_81, 1,
                                                output_81),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_82[] = {228, 16, 16, 16, 16, 11, 11, 229, 229, 16, 0};
    const uint32_t output_82[] = {230};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_AVERAGE_POOL_2D, 11,
                                                input_82, 1, output_82),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_83[] = {230, 231, 232, 16};
    const uint32_t output_83[] = {233};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_FULLY_CONNECTED, 4, input_83,
                                                1, output_83),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_84[] = {233, 234};
    const uint32_t output_84[] = {235};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_SOFTMAX, 2, input_84, 1,
                                                output_84),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_85[] = {230, 236, 237, 16};
    const uint32_t output_85[] = {238};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_FULLY_CONNECTED, 4, input_85,
                                                1, output_85),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_86[] = {184, 238, 185, 5};
    const uint32_t output_86[] = {239};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_AXIS_ALIGNED_BBOX_TRANSFORM,
                                                4, input_86, 1, output_86),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_87[] = {235, 239, 185, 240, 180, 11, 241, 242, 182};
    const uint32_t output_87[] = {243, 244, 245, 246};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, 9,
                                                input_87, 4, output_87),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_88[] = {140, 244, 246, 186, 186, 178, 178, 16, 16, 0};
    const uint32_t output_88[] = {247};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_ROI_ALIGN, 10, input_88, 1,
                                                output_88),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_89[] = {247, 248, 249, 16, 16, 16, 16, 11, 11, 11, 0};
    const uint32_t output_89[] = {250};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_89, 1,
                                                output_89),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_90[] = {250, 251, 252, 11, 11, 11, 11, 11, 11, 11, 16, 0};
    const uint32_t output_90[] = {253};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_DEPTHWISE_CONV_2D, 12,
                                                input_90, 1, output_90),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_91[] = {253, 254, 255, 16, 16, 16, 16, 11, 11, 16, 0};
    const uint32_t output_91[] = {256};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_91, 1,
                                                output_91),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_92[] = {256, 247, 16};
    const uint32_t output_92[] = {257};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_ADD, 3, input_92, 1,
                                                output_92),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_93[] = {257, 258, 259, 16, 16, 16, 16, 11, 11, 11, 0};
    const uint32_t output_93[] = {260};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_93, 1,
                                                output_93),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_94[] = {260, 261, 262, 11, 11, 11, 11, 11, 11, 11, 16, 0};
    const uint32_t output_94[] = {263};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_DEPTHWISE_CONV_2D, 12,
                                                input_94, 1, output_94),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_95[] = {263, 264, 265, 16, 16, 16, 16, 11, 11, 16, 0};
    const uint32_t output_95[] = {266};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_95, 1,
                                                output_95),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_96[] = {266, 257, 16};
    const uint32_t output_96[] = {267};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_ADD, 3, input_96, 1,
                                                output_96),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_97[] = {267, 268, 269, 16, 16, 16, 16, 11, 11, 11, 0};
    const uint32_t output_97[] = {270};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_97, 1,
                                                output_97),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_98[] = {270, 271, 272, 11, 11, 11, 11, 11, 11, 11, 16, 0};
    const uint32_t output_98[] = {273};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_DEPTHWISE_CONV_2D, 12,
                                                input_98, 1, output_98),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_99[] = {273, 274, 275, 16, 16, 16, 16, 11, 11, 16, 0};
    const uint32_t output_99[] = {276};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_99, 1,
                                                output_99),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_100[] = {276, 267, 16};
    const uint32_t output_100[] = {277};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_ADD, 3, input_100, 1,
                                                output_100),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_101[] = {277, 278, 279, 16, 16, 16, 16, 11, 11, 11, 0};
    const uint32_t output_101[] = {280};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_101, 1,
                                                output_101),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_102[] = {280, 281, 282, 11, 11, 11, 11, 11, 11, 11, 16, 0};
    const uint32_t output_102[] = {283};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_DEPTHWISE_CONV_2D, 12,
                                                input_102, 1, output_102),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_103[] = {283, 284, 285, 16, 16, 16, 16, 11, 11, 16, 0};
    const uint32_t output_103[] = {286};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_103, 1,
                                                output_103),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_104[] = {286, 277, 16};
    const uint32_t output_104[] = {287};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_ADD, 3, input_104, 1,
                                                output_104),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_105[] = {287, 288, 289, 16, 16, 16, 16, 11, 11, 11, 0};
    const uint32_t output_105[] = {290};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_105, 1,
                                                output_105),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_106[] = {290, 291, 291, 0};
    const uint32_t output_106[] = {292};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_RESIZE_NEAREST_NEIGHBOR, 4,
                                                input_106, 1, output_106),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_107[] = {292, 293, 294, 11, 11, 11, 11, 11, 11, 11, 16, 0};
    const uint32_t output_107[] = {295};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_DEPTHWISE_CONV_2D, 12,
                                                input_107, 1, output_107),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_108[] = {295, 296, 297, 16, 16, 16, 16, 11, 11, 16, 0};
    const uint32_t output_108[] = {298};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_108, 1,
                                                output_108),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_109[] = {298, 299, 300, 16, 16, 16, 16, 11, 11, 16, 0};
    const uint32_t output_109[] = {301};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_109, 1,
                                                output_109),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_110[] = {301};
    const uint32_t output_110[] = {302};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_DEQUANTIZE, 1, input_110, 1,
                                                output_110),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_111[] = {302, 303};
    const uint32_t output_111[] = {304};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_TRANSPOSE, 2, input_111, 1,
                                                output_111),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_112[] = {304};
    const uint32_t output_112[] = {305};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_LOGISTIC, 1, input_112, 1,
                                                output_112),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_113[] = {3, 306, 307};
    const uint32_t output_113[] = {308};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_SLICE, 3, input_113, 1,
                                                output_113),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t input_114[] = {243};
    const uint32_t output_114[] = {309};
    ASSERT_EQ(ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_DEQUANTIZE, 1, input_114, 1,
                                                output_114),
              ANEURALNETWORKS_NO_ERROR);
    const uint32_t model_inputs[] = {2, 3, 4, 5};
    const uint32_t model_outputs[] = {309, 244, 245, 305};
    ASSERT_EQ(
            ANeuralNetworksModel_identifyInputsAndOutputs(model, 4, model_inputs, 4, model_outputs),
            ANEURALNETWORKS_NO_ERROR);
    ASSERT_EQ(ANeuralNetworksModel_finish(model), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksCompilation* compilation = nullptr;
    ASSERT_EQ(ANeuralNetworksCompilation_create(model, &compilation), ANEURALNETWORKS_NO_ERROR);
    ASSERT_EQ(ANeuralNetworksCompilation_finish(compilation), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksExecution* execution = nullptr;
    ASSERT_EQ(ANeuralNetworksExecution_create(compilation, &execution), ANEURALNETWORKS_NO_ERROR);

    ANeuralNetworksOperandType input_operand_0{};
    input_operand_0.type = ANEURALNETWORKS_TENSOR_FLOAT32;
    input_operand_0.scale = 0;
    input_operand_0.zeroPoint = 0;
    input_operand_0.dimensionCount = 4;
    const uint32_t input_dimensions_0[] = {1, 3, 462, 320};
    input_operand_0.dimensions = input_dimensions_0;

    ASSERT_EQ(ANeuralNetworksExecution_setInput(execution, 0, &input_operand_0,
                                                execution_input_buffer_0, 1774080),
              ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType input_operand_1{};
    input_operand_1.type = ANEURALNETWORKS_TENSOR_FLOAT32;
    input_operand_1.scale = 0;
    input_operand_1.zeroPoint = 0;
    input_operand_1.dimensionCount = 2;
    const uint32_t input_dimensions_1[] = {1, 3};
    input_operand_1.dimensions = input_dimensions_1;
    const uint8_t execution_input_buffer_1[] = {0, 0, 231, 67, 0, 0, 160, 67, 198, 235, 56, 63};
    ASSERT_EQ(ANeuralNetworksExecution_setInput(execution, 1, &input_operand_1,
                                                execution_input_buffer_1, 12),
              ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType input_operand_2{};
    input_operand_2.type = ANEURALNETWORKS_TENSOR_FLOAT32;
    input_operand_2.scale = 0;
    input_operand_2.zeroPoint = 0;
    input_operand_2.dimensionCount = 2;
    const uint32_t input_dimensions_2[] = {1, 2};
    input_operand_2.dimensions = input_dimensions_2;
    const uint8_t execution_input_buffer_2[] = {0, 0, 231, 67, 0, 0, 160, 67};
    ASSERT_EQ(ANeuralNetworksExecution_setInput(execution, 2, &input_operand_2,
                                                execution_input_buffer_2, 8),
              ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksOperandType input_operand_3{};
    input_operand_3.type = ANEURALNETWORKS_TENSOR_FLOAT32;
    input_operand_3.scale = 0;
    input_operand_3.zeroPoint = 0;
    input_operand_3.dimensionCount = 2;
    const uint32_t input_dimensions_3[] = {1, 2};
    input_operand_3.dimensions = input_dimensions_3;
    const uint8_t execution_input_buffer_3[] = {112, 14, 0, 10};
    ASSERT_EQ(ANeuralNetworksExecution_setInput(execution, 3, &input_operand_3,
                                                execution_input_buffer_3, 4),
              ANEURALNETWORKS_NO_ERROR);
    static uint8_t execution_output_buffer_0[462];
    ASSERT_EQ(
            ANeuralNetworksExecution_setOutput(execution, 0, NULL, execution_output_buffer_0, 462),
            ANEURALNETWORKS_NO_ERROR);
    static uint8_t execution_output_buffer_1[924];
    ASSERT_EQ(
            ANeuralNetworksExecution_setOutput(execution, 1, NULL, execution_output_buffer_1, 924),
            ANEURALNETWORKS_NO_ERROR);
    static uint8_t execution_output_buffer_2[462];
    ASSERT_EQ(
            ANeuralNetworksExecution_setOutput(execution, 2, NULL, execution_output_buffer_2, 462),
            ANEURALNETWORKS_NO_ERROR);
    static uint8_t execution_output_buffer_3[5388768];
    ASSERT_EQ(ANeuralNetworksExecution_setOutput(execution, 3, NULL, execution_output_buffer_3,
                                                 5388768),
              ANEURALNETWORKS_NO_ERROR);
    ASSERT_EQ(ANeuralNetworksExecution_compute(execution), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksExecution_free(execution);
    ANeuralNetworksCompilation_free(compilation);
    ANeuralNetworksModel_free(model);
}

}  // namespace