Update MaskRCNN model tests following BOX_WITH_NMS_LIMIT update.

Bug: 113653053
Test: mm
Test: NeuralNetworksTest_staic
Change-Id: If3e636b835e0a0a113f1df14bbc2d3bb8eb08320

1 files changed, 332 insertions, 325 deletions

diff --git a/nn/runtime/test/TestValidateModel.cpp b/nn/runtime/test/TestValidateModel.cpp
index c65479769..a2474b9b2 100644
--- a/nn/runtime/test/TestValidateModel.cpp
+++ b/nn/runtime/test/TestValidateModel.cpp
@@ -1934,27 +1934,25 @@ TEST_F(ValidateModelTest, MaskRCNN2Go) {
     operand_241.dimensionCount = 0;
     ANeuralNetworksModel_addOperand(model, &operand_241);
     ANeuralNetworksOperandType operand_242;
-    operand_242.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
-    operand_242.scale = 0.00390625;
+    operand_242.type = ANEURALNETWORKS_FLOAT32;
+    operand_242.scale = 0;
     operand_242.zeroPoint = 0;
-    operand_242.dimensionCount = 1;
-    const uint32_t dimensions_242[] = {0};
-    operand_242.dimensions = dimensions_242;
+    operand_242.dimensionCount = 0;
     ANeuralNetworksModel_addOperand(model, &operand_242);
     ANeuralNetworksOperandType operand_243;
-    operand_243.type = ANEURALNETWORKS_TENSOR_QUANT16_ASYMM;
-    operand_243.scale = 0.125;
+    operand_243.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
+    operand_243.scale = 0.00390625;
     operand_243.zeroPoint = 0;
-    operand_243.dimensionCount = 2;
-    const uint32_t dimensions_243[] = {0, 4};
+    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_INT32;
-    operand_244.scale = 0;
+    operand_244.type = ANEURALNETWORKS_TENSOR_QUANT16_ASYMM;
+    operand_244.scale = 0.125;
     operand_244.zeroPoint = 0;
-    operand_244.dimensionCount = 1;
-    const uint32_t dimensions_244[] = {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;
@@ -1966,465 +1964,465 @@ TEST_F(ValidateModelTest, MaskRCNN2Go) {
     operand_245.dimensions = dimensions_245;
     ANeuralNetworksModel_addOperand(model, &operand_245);
     ANeuralNetworksOperandType operand_246;
-    operand_246.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
-    operand_246.scale = 0.009006229229271412;
-    operand_246.zeroPoint = 119;
-    operand_246.dimensionCount = 4;
-    const uint32_t dimensions_246[] = {0, 6, 6, 128};
+    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.002211635699495673;
-    operand_247.zeroPoint = 132;
+    operand_247.scale = 0.009006229229271412;
+    operand_247.zeroPoint = 119;
     operand_247.dimensionCount = 4;
-    const uint32_t dimensions_247[] = {512, 1, 1, 128};
+    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_INT32;
-    operand_248.scale = 1.991849785554223e-05;
-    operand_248.zeroPoint = 0;
-    operand_248.dimensionCount = 1;
-    const uint32_t dimensions_248[] = {512};
+    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_QUANT8_ASYMM;
-    operand_249.scale = 0.002592636970803142;
+    operand_249.type = ANEURALNETWORKS_TENSOR_INT32;
+    operand_249.scale = 1.991849785554223e-05;
     operand_249.zeroPoint = 0;
-    operand_249.dimensionCount = 4;
-    const uint32_t dimensions_249[] = {0, 6, 6, 512};
+    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.001000639051198959;
-    operand_250.zeroPoint = 148;
+    operand_250.scale = 0.002592636970803142;
+    operand_250.zeroPoint = 0;
     operand_250.dimensionCount = 4;
-    const uint32_t dimensions_250[] = {1, 3, 3, 512};
+    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_INT32;
-    operand_251.scale = 2.5942936190404e-06;
-    operand_251.zeroPoint = 0;
-    operand_251.dimensionCount = 1;
-    const uint32_t dimensions_251[] = {512};
+    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_QUANT8_ASYMM;
-    operand_252.scale = 0.001002595527097583;
-    operand_252.zeroPoint = 116;
-    operand_252.dimensionCount = 4;
-    const uint32_t dimensions_252[] = {0, 6, 6, 512};
+    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.01961961947381496;
-    operand_253.zeroPoint = 135;
+    operand_253.scale = 0.001002595527097583;
+    operand_253.zeroPoint = 116;
     operand_253.dimensionCount = 4;
-    const uint32_t dimensions_253[] = {128, 1, 1, 512};
+    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_INT32;
-    operand_254.scale = 1.967054413398728e-05;
-    operand_254.zeroPoint = 0;
-    operand_254.dimensionCount = 1;
-    const uint32_t dimensions_254[] = {128};
+    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_QUANT8_ASYMM;
-    operand_255.scale = 0.003791325259953737;
-    operand_255.zeroPoint = 133;
-    operand_255.dimensionCount = 4;
-    const uint32_t dimensions_255[] = {0, 6, 6, 128};
+    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.009337191469967365;
-    operand_256.zeroPoint = 121;
+    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.002133074915036559;
-    operand_257.zeroPoint = 128;
+    operand_257.scale = 0.009337191469967365;
+    operand_257.zeroPoint = 121;
     operand_257.dimensionCount = 4;
-    const uint32_t dimensions_257[] = {768, 1, 1, 128};
+    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_INT32;
-    operand_258.scale = 1.991692988667637e-05;
-    operand_258.zeroPoint = 0;
-    operand_258.dimensionCount = 1;
-    const uint32_t dimensions_258[] = {768};
+    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_QUANT8_ASYMM;
-    operand_259.scale = 0.002098787110298872;
+    operand_259.type = ANEURALNETWORKS_TENSOR_INT32;
+    operand_259.scale = 1.991692988667637e-05;
     operand_259.zeroPoint = 0;
-    operand_259.dimensionCount = 4;
-    const uint32_t dimensions_259[] = {0, 6, 6, 768};
+    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.0008608275675214827;
-    operand_260.zeroPoint = 124;
+    operand_260.scale = 0.002098787110298872;
+    operand_260.zeroPoint = 0;
     operand_260.dimensionCount = 4;
-    const uint32_t dimensions_260[] = {1, 3, 3, 768};
+    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_INT32;
-    operand_261.scale = 1.806693830985751e-06;
-    operand_261.zeroPoint = 0;
-    operand_261.dimensionCount = 1;
-    const uint32_t dimensions_261[] = {768};
+    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_QUANT8_ASYMM;
-    operand_262.scale = 0.001001805765554309;
-    operand_262.zeroPoint = 150;
-    operand_262.dimensionCount = 4;
-    const uint32_t dimensions_262[] = {0, 6, 6, 768};
+    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.0244825966656208;
-    operand_263.zeroPoint = 125;
+    operand_263.scale = 0.001001805765554309;
+    operand_263.zeroPoint = 150;
     operand_263.dimensionCount = 4;
-    const uint32_t dimensions_263[] = {128, 1, 1, 768};
+    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_INT32;
-    operand_264.scale = 2.452680564601906e-05;
-    operand_264.zeroPoint = 0;
-    operand_264.dimensionCount = 1;
-    const uint32_t dimensions_264[] = {128};
+    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_QUANT8_ASYMM;
-    operand_265.scale = 0.003958381246775389;
-    operand_265.zeroPoint = 126;
-    operand_265.dimensionCount = 4;
-    const uint32_t dimensions_265[] = {0, 6, 6, 128};
+    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.009366916492581367;
-    operand_266.zeroPoint = 121;
+    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.002321642125025392;
+    operand_267.scale = 0.009366916492581367;
     operand_267.zeroPoint = 121;
     operand_267.dimensionCount = 4;
-    const uint32_t dimensions_267[] = {768, 1, 1, 128};
+    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_INT32;
-    operand_268.scale = 2.17466258618515e-05;
-    operand_268.zeroPoint = 0;
-    operand_268.dimensionCount = 1;
-    const uint32_t dimensions_268[] = {768};
+    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_QUANT8_ASYMM;
-    operand_269.scale = 0.002672255504876375;
+    operand_269.type = ANEURALNETWORKS_TENSOR_INT32;
+    operand_269.scale = 2.17466258618515e-05;
     operand_269.zeroPoint = 0;
-    operand_269.dimensionCount = 4;
-    const uint32_t dimensions_269[] = {0, 6, 6, 768};
+    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.0008156994008459151;
-    operand_270.zeroPoint = 131;
+    operand_270.scale = 0.002672255504876375;
+    operand_270.zeroPoint = 0;
     operand_270.dimensionCount = 4;
-    const uint32_t dimensions_270[] = {1, 3, 3, 768};
+    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_INT32;
-    operand_271.scale = 2.179757075282396e-06;
-    operand_271.zeroPoint = 0;
-    operand_271.dimensionCount = 1;
-    const uint32_t dimensions_271[] = {768};
+    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_QUANT8_ASYMM;
-    operand_272.scale = 0.00100218434818089;
-    operand_272.zeroPoint = 104;
-    operand_272.dimensionCount = 4;
-    const uint32_t dimensions_272[] = {0, 6, 6, 768};
+    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.02847485058009624;
-    operand_273.zeroPoint = 121;
+    operand_273.scale = 0.00100218434818089;
+    operand_273.zeroPoint = 104;
     operand_273.dimensionCount = 4;
-    const uint32_t dimensions_273[] = {128, 1, 1, 768};
+    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_INT32;
-    operand_274.scale = 2.853704972949345e-05;
-    operand_274.zeroPoint = 0;
-    operand_274.dimensionCount = 1;
-    const uint32_t dimensions_274[] = {128};
+    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_QUANT8_ASYMM;
-    operand_275.scale = 0.005113502498716116;
-    operand_275.zeroPoint = 134;
-    operand_275.dimensionCount = 4;
-    const uint32_t dimensions_275[] = {0, 6, 6, 128};
+    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.009635390713810921;
-    operand_276.zeroPoint = 126;
+    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.002073407173156738;
-    operand_277.zeroPoint = 138;
+    operand_277.scale = 0.009635390713810921;
+    operand_277.zeroPoint = 126;
     operand_277.dimensionCount = 4;
-    const uint32_t dimensions_277[] = {768, 1, 1, 128};
+    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_INT32;
-    operand_278.scale = 1.997808794840239e-05;
-    operand_278.zeroPoint = 0;
-    operand_278.dimensionCount = 1;
-    const uint32_t dimensions_278[] = {768};
+    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_QUANT8_ASYMM;
-    operand_279.scale = 0.00225812871940434;
+    operand_279.type = ANEURALNETWORKS_TENSOR_INT32;
+    operand_279.scale = 1.997808794840239e-05;
     operand_279.zeroPoint = 0;
-    operand_279.dimensionCount = 4;
-    const uint32_t dimensions_279[] = {0, 6, 6, 768};
+    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.0009067427599802613;
-    operand_280.zeroPoint = 116;
+    operand_280.scale = 0.00225812871940434;
+    operand_280.zeroPoint = 0;
     operand_280.dimensionCount = 4;
-    const uint32_t dimensions_280[] = {1, 3, 3, 768};
+    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_INT32;
-    operand_281.scale = 2.047542011496262e-06;
-    operand_281.zeroPoint = 0;
-    operand_281.dimensionCount = 1;
-    const uint32_t dimensions_281[] = {768};
+    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_QUANT8_ASYMM;
-    operand_282.scale = 0.001002039294689894;
-    operand_282.zeroPoint = 121;
-    operand_282.dimensionCount = 4;
-    const uint32_t dimensions_282[] = {0, 6, 6, 768};
+    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.0345500223338604;
-    operand_283.zeroPoint = 134;
+    operand_283.scale = 0.001002039294689894;
+    operand_283.zeroPoint = 121;
     operand_283.dimensionCount = 4;
-    const uint32_t dimensions_283[] = {128, 1, 1, 768};
+    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_INT32;
-    operand_284.scale = 3.462047970970161e-05;
-    operand_284.zeroPoint = 0;
-    operand_284.dimensionCount = 1;
-    const uint32_t dimensions_284[] = {128};
+    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_QUANT8_ASYMM;
-    operand_285.scale = 0.005219598766416311;
-    operand_285.zeroPoint = 129;
-    operand_285.dimensionCount = 4;
-    const uint32_t dimensions_285[] = {0, 6, 6, 128};
+    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.01011695526540279;
-    operand_286.zeroPoint = 125;
+    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.002151809399947524;
-    operand_287.zeroPoint = 134;
+    operand_287.scale = 0.01011695526540279;
+    operand_287.zeroPoint = 125;
     operand_287.dimensionCount = 4;
-    const uint32_t dimensions_287[] = {384, 1, 1, 128};
+    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_INT32;
-    operand_288.scale = 2.176975976908579e-05;
-    operand_288.zeroPoint = 0;
-    operand_288.dimensionCount = 1;
-    const uint32_t dimensions_288[] = {384};
+    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_QUANT8_ASYMM;
-    operand_289.scale = 0.003372935345396399;
+    operand_289.type = ANEURALNETWORKS_TENSOR_INT32;
+    operand_289.scale = 2.176975976908579e-05;
     operand_289.zeroPoint = 0;
-    operand_289.dimensionCount = 4;
-    const uint32_t dimensions_289[] = {0, 6, 6, 384};
+    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_INT32;
-    operand_290.scale = 0;
+    operand_290.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
+    operand_290.scale = 0.003372935345396399;
     operand_290.zeroPoint = 0;
-    operand_290.dimensionCount = 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_TENSOR_QUANT8_ASYMM;
-    operand_291.scale = 0.003372935345396399;
+    operand_291.type = ANEURALNETWORKS_FLOAT32;
+    operand_291.scale = 0;
     operand_291.zeroPoint = 0;
-    operand_291.dimensionCount = 4;
-    const uint32_t dimensions_291[] = {0, 12, 12, 384};
-    operand_291.dimensions = dimensions_291;
+    operand_291.dimensionCount = 0;
     ANeuralNetworksModel_addOperand(model, &operand_291);
     ANeuralNetworksOperandType operand_292;
     operand_292.type = ANEURALNETWORKS_TENSOR_QUANT8_ASYMM;
-    operand_292.scale = 0.001229611807502806;
-    operand_292.zeroPoint = 134;
+    operand_292.scale = 0.003372935345396399;
+    operand_292.zeroPoint = 0;
     operand_292.dimensionCount = 4;
-    const uint32_t dimensions_292[] = {1, 3, 3, 384};
+    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_INT32;
-    operand_293.scale = 4.147401341469958e-06;
-    operand_293.zeroPoint = 0;
-    operand_293.dimensionCount = 1;
-    const uint32_t dimensions_293[] = {384};
+    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_QUANT8_ASYMM;
-    operand_294.scale = 0.001418625121004879;
-    operand_294.zeroPoint = 129;
-    operand_294.dimensionCount = 4;
-    const uint32_t dimensions_294[] = {0, 12, 12, 384};
+    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.06397756934165955;
-    operand_295.zeroPoint = 123;
+    operand_295.scale = 0.001418625121004879;
+    operand_295.zeroPoint = 129;
     operand_295.dimensionCount = 4;
-    const uint32_t dimensions_295[] = {64, 1, 1, 384};
+    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_INT32;
-    operand_296.scale = 9.076018613995984e-05;
-    operand_296.zeroPoint = 0;
-    operand_296.dimensionCount = 1;
-    const uint32_t dimensions_296[] = {64};
+    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_QUANT8_ASYMM;
-    operand_297.scale = 0.04541563242673874;
-    operand_297.zeroPoint = 145;
-    operand_297.dimensionCount = 4;
-    const uint32_t dimensions_297[] = {0, 12, 12, 64};
+    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.003162507666274905;
-    operand_298.zeroPoint = 127;
+    operand_298.scale = 0.04541563242673874;
+    operand_298.zeroPoint = 145;
     operand_298.dimensionCount = 4;
-    const uint32_t dimensions_298[] = {81, 1, 1, 64};
+    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_INT32;
-    operand_299.scale = 0.000143627286888659;
-    operand_299.zeroPoint = 0;
-    operand_299.dimensionCount = 1;
-    const uint32_t dimensions_299[] = {81};
+    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_QUANT8_ASYMM;
-    operand_300.scale = 0.08356435596942902;
-    operand_300.zeroPoint = 135;
-    operand_300.dimensionCount = 4;
-    const uint32_t dimensions_300[] = {0, 12, 12, 81};
+    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_FLOAT32;
-    operand_301.scale = 0;
-    operand_301.zeroPoint = 0;
+    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_INT32;
+    operand_302.type = ANEURALNETWORKS_TENSOR_FLOAT32;
     operand_302.scale = 0;
     operand_302.zeroPoint = 0;
-    operand_302.dimensionCount = 1;
-    const uint32_t dimensions_302[] = {4};
+    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_FLOAT32;
+    operand_303.type = ANEURALNETWORKS_TENSOR_INT32;
     operand_303.scale = 0;
     operand_303.zeroPoint = 0;
-    operand_303.dimensionCount = 4;
-    const uint32_t dimensions_303[] = {0, 81, 12, 12};
+    operand_303.dimensionCount = 1;
+    const uint32_t dimensions_303[] = {4};
     operand_303.dimensions = dimensions_303;
     ANeuralNetworksModel_addOperand(model, &operand_303);
     ANeuralNetworksOperandType operand_304;
@@ -2436,11 +2434,11 @@ TEST_F(ValidateModelTest, MaskRCNN2Go) {
     operand_304.dimensions = dimensions_304;
     ANeuralNetworksModel_addOperand(model, &operand_304);
     ANeuralNetworksOperandType operand_305;
-    operand_305.type = ANEURALNETWORKS_TENSOR_INT32;
+    operand_305.type = ANEURALNETWORKS_TENSOR_FLOAT32;
     operand_305.scale = 0;
     operand_305.zeroPoint = 0;
-    operand_305.dimensionCount = 1;
-    const uint32_t dimensions_305[] = {2};
+    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;
@@ -2452,21 +2450,29 @@ TEST_F(ValidateModelTest, MaskRCNN2Go) {
     operand_306.dimensions = dimensions_306;
     ANeuralNetworksModel_addOperand(model, &operand_306);
     ANeuralNetworksOperandType operand_307;
-    operand_307.type = ANEURALNETWORKS_TENSOR_FLOAT32;
+    operand_307.type = ANEURALNETWORKS_TENSOR_INT32;
     operand_307.scale = 0;
     operand_307.zeroPoint = 0;
-    operand_307.dimensionCount = 2;
-    const uint32_t dimensions_307[] = {1, 1};
+    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 = 1;
-    const uint32_t dimensions_308[] = {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};
@@ -2754,104 +2760,105 @@ TEST_F(ValidateModelTest, MaskRCNN2Go) {
     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, 16, 241, 241, 241};
-    const uint32_t output_87[] = {242, 243, 244, 245};
+    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, 243, 245, 186, 186, 178, 178, 16, 16, 0};
-    const uint32_t output_88[] = {246};
+    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[] = {246, 247, 248, 16, 16, 16, 16, 11, 11, 11, 0};
-    const uint32_t output_89[] = {249};
+    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[] = {249, 250, 251, 11, 11, 11, 11, 11, 11, 11, 16, 0};
-    const uint32_t output_90[] = {252};
+    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[] = {252, 253, 254, 16, 16, 16, 16, 11, 11, 16, 0};
-    const uint32_t output_91[] = {255};
+    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[] = {255, 246, 16};
-    const uint32_t output_92[] = {256};
+    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[] = {256, 257, 258, 16, 16, 16, 16, 11, 11, 11, 0};
-    const uint32_t output_93[] = {259};
+    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[] = {259, 260, 261, 11, 11, 11, 11, 11, 11, 11, 16, 0};
-    const uint32_t output_94[] = {262};
+    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[] = {262, 263, 264, 16, 16, 16, 16, 11, 11, 16, 0};
-    const uint32_t output_95[] = {265};
+    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[] = {265, 256, 16};
-    const uint32_t output_96[] = {266};
+    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[] = {266, 267, 268, 16, 16, 16, 16, 11, 11, 11, 0};
-    const uint32_t output_97[] = {269};
+    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[] = {269, 270, 271, 11, 11, 11, 11, 11, 11, 11, 16, 0};
-    const uint32_t output_98[] = {272};
+    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[] = {272, 273, 274, 16, 16, 16, 16, 11, 11, 16, 0};
-    const uint32_t output_99[] = {275};
+    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[] = {275, 266, 16};
-    const uint32_t output_100[] = {276};
+    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[] = {276, 277, 278, 16, 16, 16, 16, 11, 11, 11, 0};
-    const uint32_t output_101[] = {279};
+    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[] = {279, 280, 281, 11, 11, 11, 11, 11, 11, 11, 16, 0};
-    const uint32_t output_102[] = {282};
+    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[] = {282, 283, 284, 16, 16, 16, 16, 11, 11, 16, 0};
-    const uint32_t output_103[] = {285};
+    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[] = {285, 276, 16};
-    const uint32_t output_104[] = {286};
+    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[] = {286, 287, 288, 16, 16, 16, 16, 11, 11, 11, 0};
-    const uint32_t output_105[] = {289};
+    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[] = {289, 290, 290, 0};
-    const uint32_t output_106[] = {291};
+    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[] = {291, 292, 293, 11, 11, 11, 11, 11, 11, 11, 16, 0};
-    const uint32_t output_107[] = {294};
+    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[] = {294, 295, 296, 16, 16, 16, 16, 11, 11, 16, 0};
-    const uint32_t output_108[] = {297};
+    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[] = {297, 298, 299, 16, 16, 16, 16, 11, 11, 16, 0};
-    const uint32_t output_109[] = {300};
+    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[] = {300};
-    const uint32_t output_110[] = {301};
+    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[] = {301, 302};
-    const uint32_t output_111[] = {303};
+    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[] = {303};
-    const uint32_t output_112[] = {304};
+    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, 305, 306};
-    const uint32_t output_113[] = {307};
+    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[] = {242};
-    const uint32_t output_114[] = {308};
+    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[] = {308, 243, 244, 304};
-
-    ANeuralNetworksModel_identifyInputsAndOutputs(model, 4, model_inputs, 4, model_outputs);
+    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);
@@ -2864,11 +2871,11 @@ TEST_F(ValidateModelTest, MaskRCNN2Go) {
     input_operand_0.scale = 0;
     input_operand_0.zeroPoint = 0;
     input_operand_0.dimensionCount = 4;
-    const uint32_t input_dimensions_0[] = {1, 3, 320, 448};
+    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,
-                                      1720320);
+                                      1774080);
     ANeuralNetworksOperandType input_operand_1;
     input_operand_1.type = ANEURALNETWORKS_TENSOR_FLOAT32;
     input_operand_1.scale = 0;
@@ -2876,7 +2883,7 @@ TEST_F(ValidateModelTest, MaskRCNN2Go) {
     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, 160, 67, 0, 0, 224, 67, 138, 65, 51, 63};
+    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;
@@ -2885,7 +2892,7 @@ TEST_F(ValidateModelTest, MaskRCNN2Go) {
     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, 160, 67, 0, 0, 224, 67};
+    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;
@@ -2894,16 +2901,16 @@ TEST_F(ValidateModelTest, MaskRCNN2Go) {
     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[] = {0, 10, 0, 14};
+    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[32];
-    ANeuralNetworksExecution_setOutput(execution, 0, NULL, execution_output_buffer_0, 32);
-    static uint8_t execution_output_buffer_1[64];
-    ANeuralNetworksExecution_setOutput(execution, 1, NULL, execution_output_buffer_1, 64);
-    static uint8_t execution_output_buffer_2[32];
-    ANeuralNetworksExecution_setOutput(execution, 2, NULL, execution_output_buffer_2, 32);
-    static uint8_t execution_output_buffer_3[326592];
-    ANeuralNetworksExecution_setOutput(execution, 3, NULL, execution_output_buffer_3, 326592);
+    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);