/*
 * 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;
    ANeuralNetworksModel_create(&model);
    ANeuralNetworksOperandType operand_0;
    operand_0.type = ANEURALNETWORKS_BOOL;
    operand_0.scale = 0;
    operand_0.zeroPoint = 0;
    operand_0.dimensionCount = 0;
    ANeuralNetworksModel_addOperand(model, &operand_0);
    ANeuralNetworksOperandType operand_1;
    operand_1.type = ANEURALNETWORKS_BOOL;
    operand_1.scale = 0;
    operand_1.zeroPoint = 0;
    operand_1.dimensionCount = 0;
    ANeuralNetworksModel_addOperand(model, &operand_1);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_2);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_3);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_4);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_5);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_6);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_7);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_8);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_9);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_10);
    ANeuralNetworksOperandType operand_11;
    operand_11.type = ANEURALNETWORKS_INT32;
    operand_11.scale = 0;
    operand_11.zeroPoint = 0;
    operand_11.dimensionCount = 0;
    ANeuralNetworksModel_addOperand(model, &operand_11);
    ANeuralNetworksOperandType operand_12;
    operand_12.type = ANEURALNETWORKS_INT32;
    operand_12.scale = 0;
    operand_12.zeroPoint = 0;
    operand_12.dimensionCount = 0;
    ANeuralNetworksModel_addOperand(model, &operand_12);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_13);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_14);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_15);
    ANeuralNetworksOperandType operand_16;
    operand_16.type = ANEURALNETWORKS_INT32;
    operand_16.scale = 0;
    operand_16.zeroPoint = 0;
    operand_16.dimensionCount = 0;
    ANeuralNetworksModel_addOperand(model, &operand_16);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_17);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_18);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_19);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_20);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_21);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_22);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_23);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_24);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_25);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_26);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_27);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_28);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_29);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_30);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_31);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_32);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_33);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_34);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_35);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_36);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_37);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_38);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_39);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_40);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_41);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_42);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_43);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_44);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_45);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_46);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_47);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_48);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_49);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_50);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_51);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_52);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_53);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_54);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_55);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_56);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_57);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_58);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_59);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_60);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_61);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_62);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_63);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_64);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_65);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_66);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_67);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_68);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_69);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_70);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_71);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_72);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_73);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_74);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_75);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_76);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_77);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_78);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_79);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_80);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_81);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_82);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_83);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_84);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_85);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_86);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_87);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_88);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_89);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_90);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_91);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_92);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_93);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_94);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_95);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_96);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_97);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_98);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_99);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_100);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_101);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_102);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_103);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_104);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_105);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_106);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_107);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_108);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_109);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_110);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_111);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_112);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_113);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_114);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_115);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_116);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_117);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_118);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_119);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_120);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_121);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_122);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_123);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_124);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_125);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_126);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_127);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_128);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_129);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_130);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_131);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_132);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_133);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_134);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_135);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_136);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_137);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_138);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_139);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_140);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_141);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_142);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_143);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_144);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_145);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_146);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_147);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_148);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_149);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_150);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_151);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_152);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_153);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_154);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_155);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_156);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_157);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_158);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_159);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_160);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_161);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_162);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_163);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_164);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_165);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_166);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_167);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_168);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_169);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_170);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_171);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_172);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_173);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_174);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_175);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_176);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_177);
    ANeuralNetworksOperandType operand_178;
    operand_178.type = ANEURALNETWORKS_FLOAT32;
    operand_178.scale = 0;
    operand_178.zeroPoint = 0;
    operand_178.dimensionCount = 0;
    ANeuralNetworksModel_addOperand(model, &operand_178);
    ANeuralNetworksOperandType operand_179;
    operand_179.type = ANEURALNETWORKS_INT32;
    operand_179.scale = 0;
    operand_179.zeroPoint = 0;
    operand_179.dimensionCount = 0;
    ANeuralNetworksModel_addOperand(model, &operand_179);
    ANeuralNetworksOperandType operand_180;
    operand_180.type = ANEURALNETWORKS_INT32;
    operand_180.scale = 0;
    operand_180.zeroPoint = 0;
    operand_180.dimensionCount = 0;
    ANeuralNetworksModel_addOperand(model, &operand_180);
    ANeuralNetworksOperandType operand_181;
    operand_181.type = ANEURALNETWORKS_FLOAT32;
    operand_181.scale = 0;
    operand_181.zeroPoint = 0;
    operand_181.dimensionCount = 0;
    ANeuralNetworksModel_addOperand(model, &operand_181);
    ANeuralNetworksOperandType operand_182;
    operand_182.type = ANEURALNETWORKS_FLOAT32;
    operand_182.scale = 0;
    operand_182.zeroPoint = 0;
    operand_182.dimensionCount = 0;
    ANeuralNetworksModel_addOperand(model, &operand_182);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_183);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_184);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_185);
    ANeuralNetworksOperandType operand_186;
    operand_186.type = ANEURALNETWORKS_INT32;
    operand_186.scale = 0;
    operand_186.zeroPoint = 0;
    operand_186.dimensionCount = 0;
    ANeuralNetworksModel_addOperand(model, &operand_186);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_187);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_188);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_189);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_190);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_191);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_192);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_193);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_194);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_195);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_196);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_197);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_198);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_199);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_200);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_201);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_202);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_203);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_204);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_205);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_206);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_207);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_208);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_209);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_210);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_211);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_212);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_213);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_214);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_215);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_216);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_217);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_218);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_219);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_220);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_221);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_222);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_223);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_224);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_225);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_226);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_227);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_228);
    ANeuralNetworksOperandType operand_229;
    operand_229.type = ANEURALNETWORKS_INT32;
    operand_229.scale = 0;
    operand_229.zeroPoint = 0;
    operand_229.dimensionCount = 0;
    ANeuralNetworksModel_addOperand(model, &operand_229);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_230);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_231);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_232);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_233);
    ANeuralNetworksOperandType operand_234;
    operand_234.type = ANEURALNETWORKS_FLOAT32;
    operand_234.scale = 0;
    operand_234.zeroPoint = 0;
    operand_234.dimensionCount = 0;
    ANeuralNetworksModel_addOperand(model, &operand_234);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_235);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_236);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_237);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_238);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_239);
    ANeuralNetworksOperandType operand_240;
    operand_240.type = ANEURALNETWORKS_FLOAT32;
    operand_240.scale = 0;
    operand_240.zeroPoint = 0;
    operand_240.dimensionCount = 0;
    ANeuralNetworksModel_addOperand(model, &operand_240);
    ANeuralNetworksOperandType operand_241;
    operand_241.type = ANEURALNETWORKS_FLOAT32;
    operand_241.scale = 0;
    operand_241.zeroPoint = 0;
    operand_241.dimensionCount = 0;
    ANeuralNetworksModel_addOperand(model, &operand_241);
    ANeuralNetworksOperandType operand_242;
    operand_242.type = ANEURALNETWORKS_FLOAT32;
    operand_242.scale = 0;
    operand_242.zeroPoint = 0;
    operand_242.dimensionCount = 0;
    ANeuralNetworksModel_addOperand(model, &operand_242);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_243);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_244);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_245);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_246);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_247);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_248);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_249);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_250);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_251);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_252);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_253);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_254);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_255);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_256);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_257);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_258);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_259);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_260);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_261);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_262);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_263);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_264);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_265);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_266);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_267);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_268);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_269);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_270);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_271);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_272);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_273);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_274);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_275);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_276);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_277);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_278);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_279);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_280);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_281);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_282);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_283);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_284);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_285);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_286);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_287);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_288);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_289);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_290);
    ANeuralNetworksOperandType operand_291;
    operand_291.type = ANEURALNETWORKS_FLOAT32;
    operand_291.scale = 0;
    operand_291.zeroPoint = 0;
    operand_291.dimensionCount = 0;
    ANeuralNetworksModel_addOperand(model, &operand_291);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_292);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_293);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_294);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_295);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_296);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_297);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_298);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_299);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_300);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_301);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_302);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_303);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_304);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_305);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_306);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_307);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_308);
    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;
    ANeuralNetworksModel_addOperand(model, &operand_309);
#include "generated/maskrcnn/maskrcnn2go_quantized_const_data.cpp"
    const uint32_t input_0[] = {2, 6};
    const uint32_t output_0[] = {7};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_TRANSPOSE, 2, input_0, 1, output_0);
    const uint32_t input_1[] = {7};
    const uint32_t output_1[] = {8};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_QUANTIZE, 1, input_1, 1, output_1);
    const uint32_t input_2[] = {8, 9, 10, 11, 11, 11, 11, 12, 12, 11, 0};
    const uint32_t output_2[] = {13};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_2, 1, output_2);
    const uint32_t input_3[] = {13, 14, 15, 16, 16, 16, 16, 11, 11, 11, 0};
    const uint32_t output_3[] = {17};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_3, 1, output_3);
    const uint32_t input_4[] = {17, 18, 19, 11, 11, 11, 11, 11, 11, 11, 16, 0};
    const uint32_t output_4[] = {20};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_DEPTHWISE_CONV_2D, 12, input_4, 1,
                                      output_4);
    const uint32_t input_5[] = {20, 21, 22, 16, 16, 16, 16, 11, 11, 16, 0};
    const uint32_t output_5[] = {23};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_5, 1, output_5);
    const uint32_t input_6[] = {23, 13, 16};
    const uint32_t output_6[] = {24};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_ADD, 3, input_6, 1, output_6);
    const uint32_t input_7[] = {24, 25, 26, 16, 16, 16, 16, 11, 11, 11, 0};
    const uint32_t output_7[] = {27};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_7, 1, output_7);
    const uint32_t input_8[] = {27, 28, 29, 11, 11, 11, 11, 12, 12, 11, 16, 0};
    const uint32_t output_8[] = {30};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_DEPTHWISE_CONV_2D, 12, input_8, 1,
                                      output_8);
    const uint32_t input_9[] = {30, 31, 32, 16, 16, 16, 16, 11, 11, 16, 0};
    const uint32_t output_9[] = {33};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_9, 1, output_9);
    const uint32_t input_10[] = {33, 34, 35, 16, 16, 16, 16, 11, 11, 11, 0};
    const uint32_t output_10[] = {36};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_10, 1, output_10);
    const uint32_t input_11[] = {36, 37, 38, 11, 11, 11, 11, 11, 11, 11, 16, 0};
    const uint32_t output_11[] = {39};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_DEPTHWISE_CONV_2D, 12, input_11, 1,
                                      output_11);
    const uint32_t input_12[] = {39, 40, 41, 16, 16, 16, 16, 11, 11, 16, 0};
    const uint32_t output_12[] = {42};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_12, 1, output_12);
    const uint32_t input_13[] = {42, 33, 16};
    const uint32_t output_13[] = {43};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_ADD, 3, input_13, 1, output_13);
    const uint32_t input_14[] = {43, 44, 45, 16, 16, 16, 16, 11, 11, 11, 0};
    const uint32_t output_14[] = {46};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_14, 1, output_14);
    const uint32_t input_15[] = {46, 47, 48, 11, 11, 11, 11, 12, 12, 11, 16, 0};
    const uint32_t output_15[] = {49};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_DEPTHWISE_CONV_2D, 12, input_15, 1,
                                      output_15);
    const uint32_t input_16[] = {49, 50, 51, 16, 16, 16, 16, 11, 11, 16, 0};
    const uint32_t output_16[] = {52};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_16, 1, output_16);
    const uint32_t input_17[] = {52, 53, 54, 16, 16, 16, 16, 11, 11, 11, 0};
    const uint32_t output_17[] = {55};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_17, 1, output_17);
    const uint32_t input_18[] = {55, 56, 57, 11, 11, 11, 11, 11, 11, 11, 16, 0};
    const uint32_t output_18[] = {58};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_DEPTHWISE_CONV_2D, 12, input_18, 1,
                                      output_18);
    const uint32_t input_19[] = {58, 59, 60, 16, 16, 16, 16, 11, 11, 16, 0};
    const uint32_t output_19[] = {61};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_19, 1, output_19);
    const uint32_t input_20[] = {61, 52, 16};
    const uint32_t output_20[] = {62};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_ADD, 3, input_20, 1, output_20);
    const uint32_t input_21[] = {62, 63, 64, 16, 16, 16, 16, 11, 11, 11, 0};
    const uint32_t output_21[] = {65};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_21, 1, output_21);
    const uint32_t input_22[] = {65, 66, 67, 11, 11, 11, 11, 11, 11, 11, 16, 0};
    const uint32_t output_22[] = {68};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_DEPTHWISE_CONV_2D, 12, input_22, 1,
                                      output_22);
    const uint32_t input_23[] = {68, 69, 70, 16, 16, 16, 16, 11, 11, 16, 0};
    const uint32_t output_23[] = {71};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_23, 1, output_23);
    const uint32_t input_24[] = {71, 62, 16};
    const uint32_t output_24[] = {72};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_ADD, 3, input_24, 1, output_24);
    const uint32_t input_25[] = {72, 73, 74, 16, 16, 16, 16, 11, 11, 11, 0};
    const uint32_t output_25[] = {75};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_25, 1, output_25);
    const uint32_t input_26[] = {75, 76, 77, 11, 11, 11, 11, 12, 12, 11, 16, 0};
    const uint32_t output_26[] = {78};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_DEPTHWISE_CONV_2D, 12, input_26, 1,
                                      output_26);
    const uint32_t input_27[] = {78, 79, 80, 16, 16, 16, 16, 11, 11, 16, 0};
    const uint32_t output_27[] = {81};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_27, 1, output_27);
    const uint32_t input_28[] = {81, 82, 83, 16, 16, 16, 16, 11, 11, 11, 0};
    const uint32_t output_28[] = {84};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_28, 1, output_28);
    const uint32_t input_29[] = {84, 85, 86, 11, 11, 11, 11, 11, 11, 11, 16, 0};
    const uint32_t output_29[] = {87};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_DEPTHWISE_CONV_2D, 12, input_29, 1,
                                      output_29);
    const uint32_t input_30[] = {87, 88, 89, 16, 16, 16, 16, 11, 11, 16, 0};
    const uint32_t output_30[] = {90};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_30, 1, output_30);
    const uint32_t input_31[] = {90, 81, 16};
    const uint32_t output_31[] = {91};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_ADD, 3, input_31, 1, output_31);
    const uint32_t input_32[] = {91, 92, 93, 16, 16, 16, 16, 11, 11, 11, 0};
    const uint32_t output_32[] = {94};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_32, 1, output_32);
    const uint32_t input_33[] = {94, 95, 96, 11, 11, 11, 11, 11, 11, 11, 16, 0};
    const uint32_t output_33[] = {97};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_DEPTHWISE_CONV_2D, 12, input_33, 1,
                                      output_33);
    const uint32_t input_34[] = {97, 98, 99, 16, 16, 16, 16, 11, 11, 16, 0};
    const uint32_t output_34[] = {100};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_34, 1, output_34);
    const uint32_t input_35[] = {100, 91, 16};
    const uint32_t output_35[] = {101};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_ADD, 3, input_35, 1, output_35);
    const uint32_t input_36[] = {101, 102, 103, 16, 16, 16, 16, 11, 11, 11, 0};
    const uint32_t output_36[] = {104};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_36, 1, output_36);
    const uint32_t input_37[] = {104, 105, 106, 11, 11, 11, 11, 11, 11, 11, 16, 0};
    const uint32_t output_37[] = {107};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_DEPTHWISE_CONV_2D, 12, input_37, 1,
                                      output_37);
    const uint32_t input_38[] = {107, 108, 109, 16, 16, 16, 16, 11, 11, 16, 0};
    const uint32_t output_38[] = {110};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_38, 1, output_38);
    const uint32_t input_39[] = {110, 101, 16};
    const uint32_t output_39[] = {111};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_ADD, 3, input_39, 1, output_39);
    const uint32_t input_40[] = {111, 112, 113, 16, 16, 16, 16, 11, 11, 11, 0};
    const uint32_t output_40[] = {114};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_40, 1, output_40);
    const uint32_t input_41[] = {114, 115, 116, 11, 11, 11, 11, 11, 11, 11, 16, 0};
    const uint32_t output_41[] = {117};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_DEPTHWISE_CONV_2D, 12, input_41, 1,
                                      output_41);
    const uint32_t input_42[] = {117, 118, 119, 16, 16, 16, 16, 11, 11, 16, 0};
    const uint32_t output_42[] = {120};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_42, 1, output_42);
    const uint32_t input_43[] = {120, 121, 122, 16, 16, 16, 16, 11, 11, 11, 0};
    const uint32_t output_43[] = {123};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_43, 1, output_43);
    const uint32_t input_44[] = {123, 124, 125, 11, 11, 11, 11, 11, 11, 11, 16, 0};
    const uint32_t output_44[] = {126};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_DEPTHWISE_CONV_2D, 12, input_44, 1,
                                      output_44);
    const uint32_t input_45[] = {126, 127, 128, 16, 16, 16, 16, 11, 11, 16, 0};
    const uint32_t output_45[] = {129};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_45, 1, output_45);
    const uint32_t input_46[] = {129, 120, 16};
    const uint32_t output_46[] = {130};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_ADD, 3, input_46, 1, output_46);
    const uint32_t input_47[] = {130, 131, 132, 16, 16, 16, 16, 11, 11, 11, 0};
    const uint32_t output_47[] = {133};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_47, 1, output_47);
    const uint32_t input_48[] = {133, 134, 135, 11, 11, 11, 11, 11, 11, 11, 16, 0};
    const uint32_t output_48[] = {136};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_DEPTHWISE_CONV_2D, 12, input_48, 1,
                                      output_48);
    const uint32_t input_49[] = {136, 137, 138, 16, 16, 16, 16, 11, 11, 16, 0};
    const uint32_t output_49[] = {139};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_49, 1, output_49);
    const uint32_t input_50[] = {139, 130, 16};
    const uint32_t output_50[] = {140};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_ADD, 3, input_50, 1, output_50);
    const uint32_t input_51[] = {140, 141, 142, 16, 16, 16, 16, 11, 11, 11, 0};
    const uint32_t output_51[] = {143};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_51, 1, output_51);
    const uint32_t input_52[] = {143, 144, 145, 11, 11, 11, 11, 11, 11, 11, 16, 0};
    const uint32_t output_52[] = {146};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_DEPTHWISE_CONV_2D, 12, input_52, 1,
                                      output_52);
    const uint32_t input_53[] = {146, 147, 148, 16, 16, 16, 16, 11, 11, 16, 0};
    const uint32_t output_53[] = {149};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_53, 1, output_53);
    const uint32_t input_54[] = {149, 140, 16};
    const uint32_t output_54[] = {150};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_ADD, 3, input_54, 1, output_54);
    const uint32_t input_55[] = {150, 151, 152, 16, 16, 16, 16, 11, 11, 11, 0};
    const uint32_t output_55[] = {153};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_55, 1, output_55);
    const uint32_t input_56[] = {153, 154, 155, 11, 11, 11, 11, 11, 11, 11, 16, 0};
    const uint32_t output_56[] = {156};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_DEPTHWISE_CONV_2D, 12, input_56, 1,
                                      output_56);
    const uint32_t input_57[] = {156, 157, 158, 16, 16, 16, 16, 11, 11, 16, 0};
    const uint32_t output_57[] = {159};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_57, 1, output_57);
    const uint32_t input_58[] = {159, 150, 16};
    const uint32_t output_58[] = {160};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_ADD, 3, input_58, 1, output_58);
    const uint32_t input_59[] = {160, 161, 162, 16, 16, 16, 16, 11, 11, 11, 0};
    const uint32_t output_59[] = {163};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_59, 1, output_59);
    const uint32_t input_60[] = {163, 164, 165, 11, 11, 11, 11, 11, 11, 11, 16, 0};
    const uint32_t output_60[] = {166};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_DEPTHWISE_CONV_2D, 12, input_60, 1,
                                      output_60);
    const uint32_t input_61[] = {166, 167, 168, 16, 16, 16, 16, 11, 11, 16, 0};
    const uint32_t output_61[] = {169};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_61, 1, output_61);
    const uint32_t input_62[] = {169, 160, 16};
    const uint32_t output_62[] = {170};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_ADD, 3, input_62, 1, output_62);
    const uint32_t input_63[] = {170, 171, 172, 16, 16, 16, 16, 11, 11, 16, 0};
    const uint32_t output_63[] = {173};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_63, 1, output_63);
    const uint32_t input_64[] = {170, 174, 175, 16, 16, 16, 16, 11, 11, 16, 0};
    const uint32_t output_64[] = {176};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_64, 1, output_64);
    const uint32_t input_65[] = {173, 176, 177, 5, 178, 178, 179, 180, 181, 182, 0};
    const uint32_t output_65[] = {183, 184, 185};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_GENERATE_PROPOSALS, 11, input_65, 3,
                                      output_65);
    const uint32_t input_66[] = {140, 184, 185, 186, 186, 178, 178, 16, 16, 0};
    const uint32_t output_66[] = {187};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_ROI_ALIGN, 10, input_66, 1, output_66);
    const uint32_t input_67[] = {187, 188, 189, 16, 16, 16, 16, 11, 11, 11, 0};
    const uint32_t output_67[] = {190};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_67, 1, output_67);
    const uint32_t input_68[] = {190, 191, 192, 11, 11, 11, 11, 12, 12, 11, 16, 0};
    const uint32_t output_68[] = {193};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_DEPTHWISE_CONV_2D, 12, input_68, 1,
                                      output_68);
    const uint32_t input_69[] = {193, 194, 195, 16, 16, 16, 16, 11, 11, 16, 0};
    const uint32_t output_69[] = {196};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_69, 1, output_69);
    const uint32_t input_70[] = {196, 197, 198, 16, 16, 16, 16, 11, 11, 11, 0};
    const uint32_t output_70[] = {199};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_70, 1, output_70);
    const uint32_t input_71[] = {199, 200, 201, 11, 11, 11, 11, 11, 11, 11, 16, 0};
    const uint32_t output_71[] = {202};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_DEPTHWISE_CONV_2D, 12, input_71, 1,
                                      output_71);
    const uint32_t input_72[] = {202, 203, 204, 16, 16, 16, 16, 11, 11, 16, 0};
    const uint32_t output_72[] = {205};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_72, 1, output_72);
    const uint32_t input_73[] = {205, 196, 16};
    const uint32_t output_73[] = {206};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_ADD, 3, input_73, 1, output_73);
    const uint32_t input_74[] = {206, 207, 208, 16, 16, 16, 16, 11, 11, 11, 0};
    const uint32_t output_74[] = {209};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_74, 1, output_74);
    const uint32_t input_75[] = {209, 210, 211, 11, 11, 11, 11, 11, 11, 11, 16, 0};
    const uint32_t output_75[] = {212};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_DEPTHWISE_CONV_2D, 12, input_75, 1,
                                      output_75);
    const uint32_t input_76[] = {212, 213, 214, 16, 16, 16, 16, 11, 11, 16, 0};
    const uint32_t output_76[] = {215};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_76, 1, output_76);
    const uint32_t input_77[] = {215, 206, 16};
    const uint32_t output_77[] = {216};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_ADD, 3, input_77, 1, output_77);
    const uint32_t input_78[] = {216, 217, 218, 16, 16, 16, 16, 11, 11, 11, 0};
    const uint32_t output_78[] = {219};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_78, 1, output_78);
    const uint32_t input_79[] = {219, 220, 221, 11, 11, 11, 11, 11, 11, 11, 16, 0};
    const uint32_t output_79[] = {222};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_DEPTHWISE_CONV_2D, 12, input_79, 1,
                                      output_79);
    const uint32_t input_80[] = {222, 223, 224, 16, 16, 16, 16, 11, 11, 16, 0};
    const uint32_t output_80[] = {225};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_80, 1, output_80);
    const uint32_t input_81[] = {225, 226, 227, 16, 16, 16, 16, 11, 11, 11, 0};
    const uint32_t output_81[] = {228};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_81, 1, output_81);
    const uint32_t input_82[] = {228, 16, 16, 16, 16, 11, 11, 229, 229, 16, 0};
    const uint32_t output_82[] = {230};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_AVERAGE_POOL_2D, 11, input_82, 1,
                                      output_82);
    const uint32_t input_83[] = {230, 231, 232, 16};
    const uint32_t output_83[] = {233};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_FULLY_CONNECTED, 4, input_83, 1,
                                      output_83);
    const uint32_t input_84[] = {233, 234};
    const uint32_t output_84[] = {235};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_SOFTMAX, 2, input_84, 1, output_84);
    const uint32_t input_85[] = {230, 236, 237, 16};
    const uint32_t output_85[] = {238};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_FULLY_CONNECTED, 4, input_85, 1,
                                      output_85);
    const uint32_t input_86[] = {184, 238, 185, 5};
    const uint32_t output_86[] = {239};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_AXIS_ALIGNED_BBOX_TRANSFORM, 4,
                                      input_86, 1, output_86);
    const uint32_t input_87[] = {235, 239, 185, 240, 180, 11, 241, 242, 182};
    const uint32_t output_87[] = {243, 244, 245, 246};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, 9, input_87, 4,
                                      output_87);
    const uint32_t input_88[] = {140, 244, 246, 186, 186, 178, 178, 16, 16, 0};
    const uint32_t output_88[] = {247};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_ROI_ALIGN, 10, input_88, 1, output_88);
    const uint32_t input_89[] = {247, 248, 249, 16, 16, 16, 16, 11, 11, 11, 0};
    const uint32_t output_89[] = {250};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_89, 1, output_89);
    const uint32_t input_90[] = {250, 251, 252, 11, 11, 11, 11, 11, 11, 11, 16, 0};
    const uint32_t output_90[] = {253};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_DEPTHWISE_CONV_2D, 12, input_90, 1,
                                      output_90);
    const uint32_t input_91[] = {253, 254, 255, 16, 16, 16, 16, 11, 11, 16, 0};
    const uint32_t output_91[] = {256};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_91, 1, output_91);
    const uint32_t input_92[] = {256, 247, 16};
    const uint32_t output_92[] = {257};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_ADD, 3, input_92, 1, output_92);
    const uint32_t input_93[] = {257, 258, 259, 16, 16, 16, 16, 11, 11, 11, 0};
    const uint32_t output_93[] = {260};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_93, 1, output_93);
    const uint32_t input_94[] = {260, 261, 262, 11, 11, 11, 11, 11, 11, 11, 16, 0};
    const uint32_t output_94[] = {263};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_DEPTHWISE_CONV_2D, 12, input_94, 1,
                                      output_94);
    const uint32_t input_95[] = {263, 264, 265, 16, 16, 16, 16, 11, 11, 16, 0};
    const uint32_t output_95[] = {266};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_95, 1, output_95);
    const uint32_t input_96[] = {266, 257, 16};
    const uint32_t output_96[] = {267};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_ADD, 3, input_96, 1, output_96);
    const uint32_t input_97[] = {267, 268, 269, 16, 16, 16, 16, 11, 11, 11, 0};
    const uint32_t output_97[] = {270};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_97, 1, output_97);
    const uint32_t input_98[] = {270, 271, 272, 11, 11, 11, 11, 11, 11, 11, 16, 0};
    const uint32_t output_98[] = {273};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_DEPTHWISE_CONV_2D, 12, input_98, 1,
                                      output_98);
    const uint32_t input_99[] = {273, 274, 275, 16, 16, 16, 16, 11, 11, 16, 0};
    const uint32_t output_99[] = {276};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_99, 1, output_99);
    const uint32_t input_100[] = {276, 267, 16};
    const uint32_t output_100[] = {277};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_ADD, 3, input_100, 1, output_100);
    const uint32_t input_101[] = {277, 278, 279, 16, 16, 16, 16, 11, 11, 11, 0};
    const uint32_t output_101[] = {280};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_101, 1, output_101);
    const uint32_t input_102[] = {280, 281, 282, 11, 11, 11, 11, 11, 11, 11, 16, 0};
    const uint32_t output_102[] = {283};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_DEPTHWISE_CONV_2D, 12, input_102, 1,
                                      output_102);
    const uint32_t input_103[] = {283, 284, 285, 16, 16, 16, 16, 11, 11, 16, 0};
    const uint32_t output_103[] = {286};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_103, 1, output_103);
    const uint32_t input_104[] = {286, 277, 16};
    const uint32_t output_104[] = {287};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_ADD, 3, input_104, 1, output_104);
    const uint32_t input_105[] = {287, 288, 289, 16, 16, 16, 16, 11, 11, 11, 0};
    const uint32_t output_105[] = {290};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_105, 1, output_105);
    const uint32_t input_106[] = {290, 291, 291, 0};
    const uint32_t output_106[] = {292};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_RESIZE_NEAREST_NEIGHBOR, 4, input_106,
                                      1, output_106);
    const uint32_t input_107[] = {292, 293, 294, 11, 11, 11, 11, 11, 11, 11, 16, 0};
    const uint32_t output_107[] = {295};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_DEPTHWISE_CONV_2D, 12, input_107, 1,
                                      output_107);
    const uint32_t input_108[] = {295, 296, 297, 16, 16, 16, 16, 11, 11, 16, 0};
    const uint32_t output_108[] = {298};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_108, 1, output_108);
    const uint32_t input_109[] = {298, 299, 300, 16, 16, 16, 16, 11, 11, 16, 0};
    const uint32_t output_109[] = {301};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_CONV_2D, 11, input_109, 1, output_109);
    const uint32_t input_110[] = {301};
    const uint32_t output_110[] = {302};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_DEQUANTIZE, 1, input_110, 1,
                                      output_110);
    const uint32_t input_111[] = {302, 303};
    const uint32_t output_111[] = {304};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_TRANSPOSE, 2, input_111, 1,
                                      output_111);
    const uint32_t input_112[] = {304};
    const uint32_t output_112[] = {305};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_LOGISTIC, 1, input_112, 1, output_112);
    const uint32_t input_113[] = {3, 306, 307};
    const uint32_t output_113[] = {308};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_SLICE, 3, input_113, 1, output_113);
    const uint32_t input_114[] = {243};
    const uint32_t output_114[] = {309};
    ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_DEQUANTIZE, 1, input_114, 1,
                                      output_114);
    const uint32_t model_inputs[] = {2, 3, 4, 5};
    const uint32_t model_outputs[] = {309, 244, 245, 305};
    EXPECT_EQ(
            ANeuralNetworksModel_identifyInputsAndOutputs(model, 4, model_inputs, 4, model_outputs),
            ANEURALNETWORKS_NO_ERROR);
    EXPECT_EQ(ANeuralNetworksModel_finish(model), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksCompilation* compilation;
    EXPECT_EQ(ANeuralNetworksCompilation_create(model, &compilation), ANEURALNETWORKS_NO_ERROR);
    EXPECT_EQ(ANeuralNetworksCompilation_finish(compilation), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksExecution* execution;
    EXPECT_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;

    ANeuralNetworksExecution_setInput(execution, 0, &input_operand_0, execution_input_buffer_0,
                                      1774080);
    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};
    ANeuralNetworksExecution_setInput(execution, 1, &input_operand_1, execution_input_buffer_1, 12);
    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};
    ANeuralNetworksExecution_setInput(execution, 2, &input_operand_2, execution_input_buffer_2, 8);
    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};
    ANeuralNetworksExecution_setInput(execution, 3, &input_operand_3, execution_input_buffer_3, 4);
    static uint8_t execution_output_buffer_0[462];
    ANeuralNetworksExecution_setOutput(execution, 0, NULL, execution_output_buffer_0, 462);
    static uint8_t execution_output_buffer_1[924];
    ANeuralNetworksExecution_setOutput(execution, 1, NULL, execution_output_buffer_1, 924);
    static uint8_t execution_output_buffer_2[462];
    ANeuralNetworksExecution_setOutput(execution, 2, NULL, execution_output_buffer_2, 462);
    static uint8_t execution_output_buffer_3[5388768];
    ANeuralNetworksExecution_setOutput(execution, 3, NULL, execution_output_buffer_3, 5388768);
    EXPECT_EQ(ANeuralNetworksExecution_compute(execution), ANEURALNETWORKS_NO_ERROR);
    ANeuralNetworksExecution_free(execution);
    ANeuralNetworksCompilation_free(compilation);
    ANeuralNetworksModel_free(model);
}

}  // namespace