1 // clang-format off
2 // Generated file (from: sub_quantized_different_scales.mod.py). Do not edit
CreateModel(Model * model)3 void CreateModel(Model *model) {
4 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
5 OperandType type1(Type::INT32, {});
6 // Phase 1, operands
7 auto input0 = model->addOperand(&type0);
8 auto input1 = model->addOperand(&type0);
9 auto param = model->addOperand(&type1);
10 auto output0 = model->addOperand(&type0);
11 // Phase 2, operations
12 static int32_t param_init[] = {0};
13 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
14 model->addOperation(ANEURALNETWORKS_SUB, {input0, input1, param}, {output0});
15 // Phase 3, inputs and outputs
16 model->identifyInputsAndOutputs(
17 {input0, input1},
18 {output0});
19 assert(model->isValid());
20 }
21
is_ignored(int i)22 inline bool is_ignored(int i) {
23 static std::set<int> ignore = {};
24 return ignore.find(i) != ignore.end();
25 }
26
CreateModel_dynamic_output_shape(Model * model)27 void CreateModel_dynamic_output_shape(Model *model) {
28 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
29 OperandType type1(Type::INT32, {});
30 OperandType type5(Type::TENSOR_QUANT8_ASYMM, {0}, 1.0f, 0);
31 // Phase 1, operands
32 auto input0 = model->addOperand(&type0);
33 auto input1 = model->addOperand(&type0);
34 auto param = model->addOperand(&type1);
35 auto output0 = model->addOperand(&type5);
36 // Phase 2, operations
37 static int32_t param_init[] = {0};
38 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
39 model->addOperation(ANEURALNETWORKS_SUB, {input0, input1, param}, {output0});
40 // Phase 3, inputs and outputs
41 model->identifyInputsAndOutputs(
42 {input0, input1},
43 {output0});
44 assert(model->isValid());
45 }
46
is_ignored_dynamic_output_shape(int i)47 inline bool is_ignored_dynamic_output_shape(int i) {
48 static std::set<int> ignore = {};
49 return ignore.find(i) != ignore.end();
50 }
51
CreateModel_2(Model * model)52 void CreateModel_2(Model *model) {
53 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
54 OperandType type1(Type::INT32, {});
55 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
56 // Phase 1, operands
57 auto input01 = model->addOperand(&type0);
58 auto input11 = model->addOperand(&type0);
59 auto param1 = model->addOperand(&type1);
60 auto output01 = model->addOperand(&type2);
61 // Phase 2, operations
62 static int32_t param1_init[] = {0};
63 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1);
64 model->addOperation(ANEURALNETWORKS_SUB, {input01, input11, param1}, {output01});
65 // Phase 3, inputs and outputs
66 model->identifyInputsAndOutputs(
67 {input01, input11},
68 {output01});
69 assert(model->isValid());
70 }
71
is_ignored_2(int i)72 inline bool is_ignored_2(int i) {
73 static std::set<int> ignore = {};
74 return ignore.find(i) != ignore.end();
75 }
76
CreateModel_dynamic_output_shape_2(Model * model)77 void CreateModel_dynamic_output_shape_2(Model *model) {
78 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
79 OperandType type1(Type::INT32, {});
80 OperandType type6(Type::TENSOR_QUANT8_ASYMM, {0}, 1.0f, 1);
81 // Phase 1, operands
82 auto input01 = model->addOperand(&type0);
83 auto input11 = model->addOperand(&type0);
84 auto param1 = model->addOperand(&type1);
85 auto output01 = model->addOperand(&type6);
86 // Phase 2, operations
87 static int32_t param1_init[] = {0};
88 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1);
89 model->addOperation(ANEURALNETWORKS_SUB, {input01, input11, param1}, {output01});
90 // Phase 3, inputs and outputs
91 model->identifyInputsAndOutputs(
92 {input01, input11},
93 {output01});
94 assert(model->isValid());
95 }
96
is_ignored_dynamic_output_shape_2(int i)97 inline bool is_ignored_dynamic_output_shape_2(int i) {
98 static std::set<int> ignore = {};
99 return ignore.find(i) != ignore.end();
100 }
101
CreateModel_3(Model * model)102 void CreateModel_3(Model *model) {
103 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
104 OperandType type1(Type::INT32, {});
105 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
106 // Phase 1, operands
107 auto input02 = model->addOperand(&type0);
108 auto input12 = model->addOperand(&type0);
109 auto param2 = model->addOperand(&type1);
110 auto output02 = model->addOperand(&type3);
111 // Phase 2, operations
112 static int32_t param2_init[] = {0};
113 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
114 model->addOperation(ANEURALNETWORKS_SUB, {input02, input12, param2}, {output02});
115 // Phase 3, inputs and outputs
116 model->identifyInputsAndOutputs(
117 {input02, input12},
118 {output02});
119 assert(model->isValid());
120 }
121
is_ignored_3(int i)122 inline bool is_ignored_3(int i) {
123 static std::set<int> ignore = {};
124 return ignore.find(i) != ignore.end();
125 }
126
CreateModel_dynamic_output_shape_3(Model * model)127 void CreateModel_dynamic_output_shape_3(Model *model) {
128 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
129 OperandType type1(Type::INT32, {});
130 OperandType type7(Type::TENSOR_QUANT8_ASYMM, {0}, 0.01f, 120);
131 // Phase 1, operands
132 auto input02 = model->addOperand(&type0);
133 auto input12 = model->addOperand(&type0);
134 auto param2 = model->addOperand(&type1);
135 auto output02 = model->addOperand(&type7);
136 // Phase 2, operations
137 static int32_t param2_init[] = {0};
138 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
139 model->addOperation(ANEURALNETWORKS_SUB, {input02, input12, param2}, {output02});
140 // Phase 3, inputs and outputs
141 model->identifyInputsAndOutputs(
142 {input02, input12},
143 {output02});
144 assert(model->isValid());
145 }
146
is_ignored_dynamic_output_shape_3(int i)147 inline bool is_ignored_dynamic_output_shape_3(int i) {
148 static std::set<int> ignore = {};
149 return ignore.find(i) != ignore.end();
150 }
151
CreateModel_4(Model * model)152 void CreateModel_4(Model *model) {
153 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
154 OperandType type1(Type::INT32, {});
155 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
156 // Phase 1, operands
157 auto input03 = model->addOperand(&type0);
158 auto input13 = model->addOperand(&type0);
159 auto param3 = model->addOperand(&type1);
160 auto output03 = model->addOperand(&type4);
161 // Phase 2, operations
162 static int32_t param3_init[] = {0};
163 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1);
164 model->addOperation(ANEURALNETWORKS_SUB, {input03, input13, param3}, {output03});
165 // Phase 3, inputs and outputs
166 model->identifyInputsAndOutputs(
167 {input03, input13},
168 {output03});
169 assert(model->isValid());
170 }
171
is_ignored_4(int i)172 inline bool is_ignored_4(int i) {
173 static std::set<int> ignore = {};
174 return ignore.find(i) != ignore.end();
175 }
176
CreateModel_dynamic_output_shape_4(Model * model)177 void CreateModel_dynamic_output_shape_4(Model *model) {
178 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
179 OperandType type1(Type::INT32, {});
180 OperandType type8(Type::TENSOR_QUANT8_ASYMM, {0}, 10.0f, 120);
181 // Phase 1, operands
182 auto input03 = model->addOperand(&type0);
183 auto input13 = model->addOperand(&type0);
184 auto param3 = model->addOperand(&type1);
185 auto output03 = model->addOperand(&type8);
186 // Phase 2, operations
187 static int32_t param3_init[] = {0};
188 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1);
189 model->addOperation(ANEURALNETWORKS_SUB, {input03, input13, param3}, {output03});
190 // Phase 3, inputs and outputs
191 model->identifyInputsAndOutputs(
192 {input03, input13},
193 {output03});
194 assert(model->isValid());
195 }
196
is_ignored_dynamic_output_shape_4(int i)197 inline bool is_ignored_dynamic_output_shape_4(int i) {
198 static std::set<int> ignore = {};
199 return ignore.find(i) != ignore.end();
200 }
201
CreateModel_5(Model * model)202 void CreateModel_5(Model *model) {
203 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
204 OperandType type1(Type::INT32, {});
205 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
206 // Phase 1, operands
207 auto input04 = model->addOperand(&type0);
208 auto input14 = model->addOperand(&type2);
209 auto param4 = model->addOperand(&type1);
210 auto output04 = model->addOperand(&type0);
211 // Phase 2, operations
212 static int32_t param4_init[] = {0};
213 model->setOperandValue(param4, param4_init, sizeof(int32_t) * 1);
214 model->addOperation(ANEURALNETWORKS_SUB, {input04, input14, param4}, {output04});
215 // Phase 3, inputs and outputs
216 model->identifyInputsAndOutputs(
217 {input04, input14},
218 {output04});
219 assert(model->isValid());
220 }
221
is_ignored_5(int i)222 inline bool is_ignored_5(int i) {
223 static std::set<int> ignore = {};
224 return ignore.find(i) != ignore.end();
225 }
226
CreateModel_dynamic_output_shape_5(Model * model)227 void CreateModel_dynamic_output_shape_5(Model *model) {
228 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
229 OperandType type1(Type::INT32, {});
230 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
231 OperandType type5(Type::TENSOR_QUANT8_ASYMM, {0}, 1.0f, 0);
232 // Phase 1, operands
233 auto input04 = model->addOperand(&type0);
234 auto input14 = model->addOperand(&type2);
235 auto param4 = model->addOperand(&type1);
236 auto output04 = model->addOperand(&type5);
237 // Phase 2, operations
238 static int32_t param4_init[] = {0};
239 model->setOperandValue(param4, param4_init, sizeof(int32_t) * 1);
240 model->addOperation(ANEURALNETWORKS_SUB, {input04, input14, param4}, {output04});
241 // Phase 3, inputs and outputs
242 model->identifyInputsAndOutputs(
243 {input04, input14},
244 {output04});
245 assert(model->isValid());
246 }
247
is_ignored_dynamic_output_shape_5(int i)248 inline bool is_ignored_dynamic_output_shape_5(int i) {
249 static std::set<int> ignore = {};
250 return ignore.find(i) != ignore.end();
251 }
252
CreateModel_6(Model * model)253 void CreateModel_6(Model *model) {
254 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
255 OperandType type1(Type::INT32, {});
256 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
257 // Phase 1, operands
258 auto input05 = model->addOperand(&type0);
259 auto input15 = model->addOperand(&type2);
260 auto param5 = model->addOperand(&type1);
261 auto output05 = model->addOperand(&type2);
262 // Phase 2, operations
263 static int32_t param5_init[] = {0};
264 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 1);
265 model->addOperation(ANEURALNETWORKS_SUB, {input05, input15, param5}, {output05});
266 // Phase 3, inputs and outputs
267 model->identifyInputsAndOutputs(
268 {input05, input15},
269 {output05});
270 assert(model->isValid());
271 }
272
is_ignored_6(int i)273 inline bool is_ignored_6(int i) {
274 static std::set<int> ignore = {};
275 return ignore.find(i) != ignore.end();
276 }
277
CreateModel_dynamic_output_shape_6(Model * model)278 void CreateModel_dynamic_output_shape_6(Model *model) {
279 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
280 OperandType type1(Type::INT32, {});
281 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
282 OperandType type6(Type::TENSOR_QUANT8_ASYMM, {0}, 1.0f, 1);
283 // Phase 1, operands
284 auto input05 = model->addOperand(&type0);
285 auto input15 = model->addOperand(&type2);
286 auto param5 = model->addOperand(&type1);
287 auto output05 = model->addOperand(&type6);
288 // Phase 2, operations
289 static int32_t param5_init[] = {0};
290 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 1);
291 model->addOperation(ANEURALNETWORKS_SUB, {input05, input15, param5}, {output05});
292 // Phase 3, inputs and outputs
293 model->identifyInputsAndOutputs(
294 {input05, input15},
295 {output05});
296 assert(model->isValid());
297 }
298
is_ignored_dynamic_output_shape_6(int i)299 inline bool is_ignored_dynamic_output_shape_6(int i) {
300 static std::set<int> ignore = {};
301 return ignore.find(i) != ignore.end();
302 }
303
CreateModel_7(Model * model)304 void CreateModel_7(Model *model) {
305 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
306 OperandType type1(Type::INT32, {});
307 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
308 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
309 // Phase 1, operands
310 auto input06 = model->addOperand(&type0);
311 auto input16 = model->addOperand(&type2);
312 auto param6 = model->addOperand(&type1);
313 auto output06 = model->addOperand(&type3);
314 // Phase 2, operations
315 static int32_t param6_init[] = {0};
316 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1);
317 model->addOperation(ANEURALNETWORKS_SUB, {input06, input16, param6}, {output06});
318 // Phase 3, inputs and outputs
319 model->identifyInputsAndOutputs(
320 {input06, input16},
321 {output06});
322 assert(model->isValid());
323 }
324
is_ignored_7(int i)325 inline bool is_ignored_7(int i) {
326 static std::set<int> ignore = {};
327 return ignore.find(i) != ignore.end();
328 }
329
CreateModel_dynamic_output_shape_7(Model * model)330 void CreateModel_dynamic_output_shape_7(Model *model) {
331 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
332 OperandType type1(Type::INT32, {});
333 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
334 OperandType type7(Type::TENSOR_QUANT8_ASYMM, {0}, 0.01f, 120);
335 // Phase 1, operands
336 auto input06 = model->addOperand(&type0);
337 auto input16 = model->addOperand(&type2);
338 auto param6 = model->addOperand(&type1);
339 auto output06 = model->addOperand(&type7);
340 // Phase 2, operations
341 static int32_t param6_init[] = {0};
342 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1);
343 model->addOperation(ANEURALNETWORKS_SUB, {input06, input16, param6}, {output06});
344 // Phase 3, inputs and outputs
345 model->identifyInputsAndOutputs(
346 {input06, input16},
347 {output06});
348 assert(model->isValid());
349 }
350
is_ignored_dynamic_output_shape_7(int i)351 inline bool is_ignored_dynamic_output_shape_7(int i) {
352 static std::set<int> ignore = {};
353 return ignore.find(i) != ignore.end();
354 }
355
CreateModel_8(Model * model)356 void CreateModel_8(Model *model) {
357 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
358 OperandType type1(Type::INT32, {});
359 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
360 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
361 // Phase 1, operands
362 auto input07 = model->addOperand(&type0);
363 auto input17 = model->addOperand(&type2);
364 auto param7 = model->addOperand(&type1);
365 auto output07 = model->addOperand(&type4);
366 // Phase 2, operations
367 static int32_t param7_init[] = {0};
368 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
369 model->addOperation(ANEURALNETWORKS_SUB, {input07, input17, param7}, {output07});
370 // Phase 3, inputs and outputs
371 model->identifyInputsAndOutputs(
372 {input07, input17},
373 {output07});
374 assert(model->isValid());
375 }
376
is_ignored_8(int i)377 inline bool is_ignored_8(int i) {
378 static std::set<int> ignore = {};
379 return ignore.find(i) != ignore.end();
380 }
381
CreateModel_dynamic_output_shape_8(Model * model)382 void CreateModel_dynamic_output_shape_8(Model *model) {
383 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
384 OperandType type1(Type::INT32, {});
385 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
386 OperandType type8(Type::TENSOR_QUANT8_ASYMM, {0}, 10.0f, 120);
387 // Phase 1, operands
388 auto input07 = model->addOperand(&type0);
389 auto input17 = model->addOperand(&type2);
390 auto param7 = model->addOperand(&type1);
391 auto output07 = model->addOperand(&type8);
392 // Phase 2, operations
393 static int32_t param7_init[] = {0};
394 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
395 model->addOperation(ANEURALNETWORKS_SUB, {input07, input17, param7}, {output07});
396 // Phase 3, inputs and outputs
397 model->identifyInputsAndOutputs(
398 {input07, input17},
399 {output07});
400 assert(model->isValid());
401 }
402
is_ignored_dynamic_output_shape_8(int i)403 inline bool is_ignored_dynamic_output_shape_8(int i) {
404 static std::set<int> ignore = {};
405 return ignore.find(i) != ignore.end();
406 }
407
CreateModel_9(Model * model)408 void CreateModel_9(Model *model) {
409 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
410 OperandType type1(Type::INT32, {});
411 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
412 // Phase 1, operands
413 auto input08 = model->addOperand(&type0);
414 auto input18 = model->addOperand(&type3);
415 auto param8 = model->addOperand(&type1);
416 auto output08 = model->addOperand(&type0);
417 // Phase 2, operations
418 static int32_t param8_init[] = {0};
419 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
420 model->addOperation(ANEURALNETWORKS_SUB, {input08, input18, param8}, {output08});
421 // Phase 3, inputs and outputs
422 model->identifyInputsAndOutputs(
423 {input08, input18},
424 {output08});
425 assert(model->isValid());
426 }
427
is_ignored_9(int i)428 inline bool is_ignored_9(int i) {
429 static std::set<int> ignore = {};
430 return ignore.find(i) != ignore.end();
431 }
432
CreateModel_dynamic_output_shape_9(Model * model)433 void CreateModel_dynamic_output_shape_9(Model *model) {
434 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
435 OperandType type1(Type::INT32, {});
436 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
437 OperandType type5(Type::TENSOR_QUANT8_ASYMM, {0}, 1.0f, 0);
438 // Phase 1, operands
439 auto input08 = model->addOperand(&type0);
440 auto input18 = model->addOperand(&type3);
441 auto param8 = model->addOperand(&type1);
442 auto output08 = model->addOperand(&type5);
443 // Phase 2, operations
444 static int32_t param8_init[] = {0};
445 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
446 model->addOperation(ANEURALNETWORKS_SUB, {input08, input18, param8}, {output08});
447 // Phase 3, inputs and outputs
448 model->identifyInputsAndOutputs(
449 {input08, input18},
450 {output08});
451 assert(model->isValid());
452 }
453
is_ignored_dynamic_output_shape_9(int i)454 inline bool is_ignored_dynamic_output_shape_9(int i) {
455 static std::set<int> ignore = {};
456 return ignore.find(i) != ignore.end();
457 }
458
CreateModel_10(Model * model)459 void CreateModel_10(Model *model) {
460 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
461 OperandType type1(Type::INT32, {});
462 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
463 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
464 // Phase 1, operands
465 auto input09 = model->addOperand(&type0);
466 auto input19 = model->addOperand(&type3);
467 auto param9 = model->addOperand(&type1);
468 auto output09 = model->addOperand(&type2);
469 // Phase 2, operations
470 static int32_t param9_init[] = {0};
471 model->setOperandValue(param9, param9_init, sizeof(int32_t) * 1);
472 model->addOperation(ANEURALNETWORKS_SUB, {input09, input19, param9}, {output09});
473 // Phase 3, inputs and outputs
474 model->identifyInputsAndOutputs(
475 {input09, input19},
476 {output09});
477 assert(model->isValid());
478 }
479
is_ignored_10(int i)480 inline bool is_ignored_10(int i) {
481 static std::set<int> ignore = {};
482 return ignore.find(i) != ignore.end();
483 }
484
CreateModel_dynamic_output_shape_10(Model * model)485 void CreateModel_dynamic_output_shape_10(Model *model) {
486 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
487 OperandType type1(Type::INT32, {});
488 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
489 OperandType type6(Type::TENSOR_QUANT8_ASYMM, {0}, 1.0f, 1);
490 // Phase 1, operands
491 auto input09 = model->addOperand(&type0);
492 auto input19 = model->addOperand(&type3);
493 auto param9 = model->addOperand(&type1);
494 auto output09 = model->addOperand(&type6);
495 // Phase 2, operations
496 static int32_t param9_init[] = {0};
497 model->setOperandValue(param9, param9_init, sizeof(int32_t) * 1);
498 model->addOperation(ANEURALNETWORKS_SUB, {input09, input19, param9}, {output09});
499 // Phase 3, inputs and outputs
500 model->identifyInputsAndOutputs(
501 {input09, input19},
502 {output09});
503 assert(model->isValid());
504 }
505
is_ignored_dynamic_output_shape_10(int i)506 inline bool is_ignored_dynamic_output_shape_10(int i) {
507 static std::set<int> ignore = {};
508 return ignore.find(i) != ignore.end();
509 }
510
CreateModel_11(Model * model)511 void CreateModel_11(Model *model) {
512 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
513 OperandType type1(Type::INT32, {});
514 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
515 // Phase 1, operands
516 auto input010 = model->addOperand(&type0);
517 auto input110 = model->addOperand(&type3);
518 auto param10 = model->addOperand(&type1);
519 auto output010 = model->addOperand(&type3);
520 // Phase 2, operations
521 static int32_t param10_init[] = {0};
522 model->setOperandValue(param10, param10_init, sizeof(int32_t) * 1);
523 model->addOperation(ANEURALNETWORKS_SUB, {input010, input110, param10}, {output010});
524 // Phase 3, inputs and outputs
525 model->identifyInputsAndOutputs(
526 {input010, input110},
527 {output010});
528 assert(model->isValid());
529 }
530
is_ignored_11(int i)531 inline bool is_ignored_11(int i) {
532 static std::set<int> ignore = {};
533 return ignore.find(i) != ignore.end();
534 }
535
CreateModel_dynamic_output_shape_11(Model * model)536 void CreateModel_dynamic_output_shape_11(Model *model) {
537 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
538 OperandType type1(Type::INT32, {});
539 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
540 OperandType type7(Type::TENSOR_QUANT8_ASYMM, {0}, 0.01f, 120);
541 // Phase 1, operands
542 auto input010 = model->addOperand(&type0);
543 auto input110 = model->addOperand(&type3);
544 auto param10 = model->addOperand(&type1);
545 auto output010 = model->addOperand(&type7);
546 // Phase 2, operations
547 static int32_t param10_init[] = {0};
548 model->setOperandValue(param10, param10_init, sizeof(int32_t) * 1);
549 model->addOperation(ANEURALNETWORKS_SUB, {input010, input110, param10}, {output010});
550 // Phase 3, inputs and outputs
551 model->identifyInputsAndOutputs(
552 {input010, input110},
553 {output010});
554 assert(model->isValid());
555 }
556
is_ignored_dynamic_output_shape_11(int i)557 inline bool is_ignored_dynamic_output_shape_11(int i) {
558 static std::set<int> ignore = {};
559 return ignore.find(i) != ignore.end();
560 }
561
CreateModel_12(Model * model)562 void CreateModel_12(Model *model) {
563 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
564 OperandType type1(Type::INT32, {});
565 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
566 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
567 // Phase 1, operands
568 auto input011 = model->addOperand(&type0);
569 auto input111 = model->addOperand(&type3);
570 auto param11 = model->addOperand(&type1);
571 auto output011 = model->addOperand(&type4);
572 // Phase 2, operations
573 static int32_t param11_init[] = {0};
574 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
575 model->addOperation(ANEURALNETWORKS_SUB, {input011, input111, param11}, {output011});
576 // Phase 3, inputs and outputs
577 model->identifyInputsAndOutputs(
578 {input011, input111},
579 {output011});
580 assert(model->isValid());
581 }
582
is_ignored_12(int i)583 inline bool is_ignored_12(int i) {
584 static std::set<int> ignore = {};
585 return ignore.find(i) != ignore.end();
586 }
587
CreateModel_dynamic_output_shape_12(Model * model)588 void CreateModel_dynamic_output_shape_12(Model *model) {
589 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
590 OperandType type1(Type::INT32, {});
591 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
592 OperandType type8(Type::TENSOR_QUANT8_ASYMM, {0}, 10.0f, 120);
593 // Phase 1, operands
594 auto input011 = model->addOperand(&type0);
595 auto input111 = model->addOperand(&type3);
596 auto param11 = model->addOperand(&type1);
597 auto output011 = model->addOperand(&type8);
598 // Phase 2, operations
599 static int32_t param11_init[] = {0};
600 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
601 model->addOperation(ANEURALNETWORKS_SUB, {input011, input111, param11}, {output011});
602 // Phase 3, inputs and outputs
603 model->identifyInputsAndOutputs(
604 {input011, input111},
605 {output011});
606 assert(model->isValid());
607 }
608
is_ignored_dynamic_output_shape_12(int i)609 inline bool is_ignored_dynamic_output_shape_12(int i) {
610 static std::set<int> ignore = {};
611 return ignore.find(i) != ignore.end();
612 }
613
CreateModel_13(Model * model)614 void CreateModel_13(Model *model) {
615 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
616 OperandType type1(Type::INT32, {});
617 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
618 // Phase 1, operands
619 auto input012 = model->addOperand(&type0);
620 auto input112 = model->addOperand(&type4);
621 auto param12 = model->addOperand(&type1);
622 auto output012 = model->addOperand(&type0);
623 // Phase 2, operations
624 static int32_t param12_init[] = {0};
625 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
626 model->addOperation(ANEURALNETWORKS_SUB, {input012, input112, param12}, {output012});
627 // Phase 3, inputs and outputs
628 model->identifyInputsAndOutputs(
629 {input012, input112},
630 {output012});
631 assert(model->isValid());
632 }
633
is_ignored_13(int i)634 inline bool is_ignored_13(int i) {
635 static std::set<int> ignore = {};
636 return ignore.find(i) != ignore.end();
637 }
638
CreateModel_dynamic_output_shape_13(Model * model)639 void CreateModel_dynamic_output_shape_13(Model *model) {
640 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
641 OperandType type1(Type::INT32, {});
642 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
643 OperandType type5(Type::TENSOR_QUANT8_ASYMM, {0}, 1.0f, 0);
644 // Phase 1, operands
645 auto input012 = model->addOperand(&type0);
646 auto input112 = model->addOperand(&type4);
647 auto param12 = model->addOperand(&type1);
648 auto output012 = model->addOperand(&type5);
649 // Phase 2, operations
650 static int32_t param12_init[] = {0};
651 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
652 model->addOperation(ANEURALNETWORKS_SUB, {input012, input112, param12}, {output012});
653 // Phase 3, inputs and outputs
654 model->identifyInputsAndOutputs(
655 {input012, input112},
656 {output012});
657 assert(model->isValid());
658 }
659
is_ignored_dynamic_output_shape_13(int i)660 inline bool is_ignored_dynamic_output_shape_13(int i) {
661 static std::set<int> ignore = {};
662 return ignore.find(i) != ignore.end();
663 }
664
CreateModel_14(Model * model)665 void CreateModel_14(Model *model) {
666 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
667 OperandType type1(Type::INT32, {});
668 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
669 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
670 // Phase 1, operands
671 auto input013 = model->addOperand(&type0);
672 auto input113 = model->addOperand(&type4);
673 auto param13 = model->addOperand(&type1);
674 auto output013 = model->addOperand(&type2);
675 // Phase 2, operations
676 static int32_t param13_init[] = {0};
677 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1);
678 model->addOperation(ANEURALNETWORKS_SUB, {input013, input113, param13}, {output013});
679 // Phase 3, inputs and outputs
680 model->identifyInputsAndOutputs(
681 {input013, input113},
682 {output013});
683 assert(model->isValid());
684 }
685
is_ignored_14(int i)686 inline bool is_ignored_14(int i) {
687 static std::set<int> ignore = {};
688 return ignore.find(i) != ignore.end();
689 }
690
CreateModel_dynamic_output_shape_14(Model * model)691 void CreateModel_dynamic_output_shape_14(Model *model) {
692 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
693 OperandType type1(Type::INT32, {});
694 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
695 OperandType type6(Type::TENSOR_QUANT8_ASYMM, {0}, 1.0f, 1);
696 // Phase 1, operands
697 auto input013 = model->addOperand(&type0);
698 auto input113 = model->addOperand(&type4);
699 auto param13 = model->addOperand(&type1);
700 auto output013 = model->addOperand(&type6);
701 // Phase 2, operations
702 static int32_t param13_init[] = {0};
703 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1);
704 model->addOperation(ANEURALNETWORKS_SUB, {input013, input113, param13}, {output013});
705 // Phase 3, inputs and outputs
706 model->identifyInputsAndOutputs(
707 {input013, input113},
708 {output013});
709 assert(model->isValid());
710 }
711
is_ignored_dynamic_output_shape_14(int i)712 inline bool is_ignored_dynamic_output_shape_14(int i) {
713 static std::set<int> ignore = {};
714 return ignore.find(i) != ignore.end();
715 }
716
CreateModel_15(Model * model)717 void CreateModel_15(Model *model) {
718 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
719 OperandType type1(Type::INT32, {});
720 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
721 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
722 // Phase 1, operands
723 auto input014 = model->addOperand(&type0);
724 auto input114 = model->addOperand(&type4);
725 auto param14 = model->addOperand(&type1);
726 auto output014 = model->addOperand(&type3);
727 // Phase 2, operations
728 static int32_t param14_init[] = {0};
729 model->setOperandValue(param14, param14_init, sizeof(int32_t) * 1);
730 model->addOperation(ANEURALNETWORKS_SUB, {input014, input114, param14}, {output014});
731 // Phase 3, inputs and outputs
732 model->identifyInputsAndOutputs(
733 {input014, input114},
734 {output014});
735 assert(model->isValid());
736 }
737
is_ignored_15(int i)738 inline bool is_ignored_15(int i) {
739 static std::set<int> ignore = {};
740 return ignore.find(i) != ignore.end();
741 }
742
CreateModel_dynamic_output_shape_15(Model * model)743 void CreateModel_dynamic_output_shape_15(Model *model) {
744 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
745 OperandType type1(Type::INT32, {});
746 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
747 OperandType type7(Type::TENSOR_QUANT8_ASYMM, {0}, 0.01f, 120);
748 // Phase 1, operands
749 auto input014 = model->addOperand(&type0);
750 auto input114 = model->addOperand(&type4);
751 auto param14 = model->addOperand(&type1);
752 auto output014 = model->addOperand(&type7);
753 // Phase 2, operations
754 static int32_t param14_init[] = {0};
755 model->setOperandValue(param14, param14_init, sizeof(int32_t) * 1);
756 model->addOperation(ANEURALNETWORKS_SUB, {input014, input114, param14}, {output014});
757 // Phase 3, inputs and outputs
758 model->identifyInputsAndOutputs(
759 {input014, input114},
760 {output014});
761 assert(model->isValid());
762 }
763
is_ignored_dynamic_output_shape_15(int i)764 inline bool is_ignored_dynamic_output_shape_15(int i) {
765 static std::set<int> ignore = {};
766 return ignore.find(i) != ignore.end();
767 }
768
CreateModel_16(Model * model)769 void CreateModel_16(Model *model) {
770 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
771 OperandType type1(Type::INT32, {});
772 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
773 // Phase 1, operands
774 auto input015 = model->addOperand(&type0);
775 auto input115 = model->addOperand(&type4);
776 auto param15 = model->addOperand(&type1);
777 auto output015 = model->addOperand(&type4);
778 // Phase 2, operations
779 static int32_t param15_init[] = {0};
780 model->setOperandValue(param15, param15_init, sizeof(int32_t) * 1);
781 model->addOperation(ANEURALNETWORKS_SUB, {input015, input115, param15}, {output015});
782 // Phase 3, inputs and outputs
783 model->identifyInputsAndOutputs(
784 {input015, input115},
785 {output015});
786 assert(model->isValid());
787 }
788
is_ignored_16(int i)789 inline bool is_ignored_16(int i) {
790 static std::set<int> ignore = {};
791 return ignore.find(i) != ignore.end();
792 }
793
CreateModel_dynamic_output_shape_16(Model * model)794 void CreateModel_dynamic_output_shape_16(Model *model) {
795 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
796 OperandType type1(Type::INT32, {});
797 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
798 OperandType type8(Type::TENSOR_QUANT8_ASYMM, {0}, 10.0f, 120);
799 // Phase 1, operands
800 auto input015 = model->addOperand(&type0);
801 auto input115 = model->addOperand(&type4);
802 auto param15 = model->addOperand(&type1);
803 auto output015 = model->addOperand(&type8);
804 // Phase 2, operations
805 static int32_t param15_init[] = {0};
806 model->setOperandValue(param15, param15_init, sizeof(int32_t) * 1);
807 model->addOperation(ANEURALNETWORKS_SUB, {input015, input115, param15}, {output015});
808 // Phase 3, inputs and outputs
809 model->identifyInputsAndOutputs(
810 {input015, input115},
811 {output015});
812 assert(model->isValid());
813 }
814
is_ignored_dynamic_output_shape_16(int i)815 inline bool is_ignored_dynamic_output_shape_16(int i) {
816 static std::set<int> ignore = {};
817 return ignore.find(i) != ignore.end();
818 }
819
CreateModel_17(Model * model)820 void CreateModel_17(Model *model) {
821 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
822 OperandType type1(Type::INT32, {});
823 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
824 // Phase 1, operands
825 auto input016 = model->addOperand(&type2);
826 auto input116 = model->addOperand(&type0);
827 auto param16 = model->addOperand(&type1);
828 auto output016 = model->addOperand(&type0);
829 // Phase 2, operations
830 static int32_t param16_init[] = {0};
831 model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1);
832 model->addOperation(ANEURALNETWORKS_SUB, {input016, input116, param16}, {output016});
833 // Phase 3, inputs and outputs
834 model->identifyInputsAndOutputs(
835 {input016, input116},
836 {output016});
837 assert(model->isValid());
838 }
839
is_ignored_17(int i)840 inline bool is_ignored_17(int i) {
841 static std::set<int> ignore = {};
842 return ignore.find(i) != ignore.end();
843 }
844
CreateModel_dynamic_output_shape_17(Model * model)845 void CreateModel_dynamic_output_shape_17(Model *model) {
846 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
847 OperandType type1(Type::INT32, {});
848 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
849 OperandType type5(Type::TENSOR_QUANT8_ASYMM, {0}, 1.0f, 0);
850 // Phase 1, operands
851 auto input016 = model->addOperand(&type2);
852 auto input116 = model->addOperand(&type0);
853 auto param16 = model->addOperand(&type1);
854 auto output016 = model->addOperand(&type5);
855 // Phase 2, operations
856 static int32_t param16_init[] = {0};
857 model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1);
858 model->addOperation(ANEURALNETWORKS_SUB, {input016, input116, param16}, {output016});
859 // Phase 3, inputs and outputs
860 model->identifyInputsAndOutputs(
861 {input016, input116},
862 {output016});
863 assert(model->isValid());
864 }
865
is_ignored_dynamic_output_shape_17(int i)866 inline bool is_ignored_dynamic_output_shape_17(int i) {
867 static std::set<int> ignore = {};
868 return ignore.find(i) != ignore.end();
869 }
870
CreateModel_18(Model * model)871 void CreateModel_18(Model *model) {
872 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
873 OperandType type1(Type::INT32, {});
874 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
875 // Phase 1, operands
876 auto input017 = model->addOperand(&type2);
877 auto input117 = model->addOperand(&type0);
878 auto param17 = model->addOperand(&type1);
879 auto output017 = model->addOperand(&type2);
880 // Phase 2, operations
881 static int32_t param17_init[] = {0};
882 model->setOperandValue(param17, param17_init, sizeof(int32_t) * 1);
883 model->addOperation(ANEURALNETWORKS_SUB, {input017, input117, param17}, {output017});
884 // Phase 3, inputs and outputs
885 model->identifyInputsAndOutputs(
886 {input017, input117},
887 {output017});
888 assert(model->isValid());
889 }
890
is_ignored_18(int i)891 inline bool is_ignored_18(int i) {
892 static std::set<int> ignore = {};
893 return ignore.find(i) != ignore.end();
894 }
895
CreateModel_dynamic_output_shape_18(Model * model)896 void CreateModel_dynamic_output_shape_18(Model *model) {
897 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
898 OperandType type1(Type::INT32, {});
899 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
900 OperandType type6(Type::TENSOR_QUANT8_ASYMM, {0}, 1.0f, 1);
901 // Phase 1, operands
902 auto input017 = model->addOperand(&type2);
903 auto input117 = model->addOperand(&type0);
904 auto param17 = model->addOperand(&type1);
905 auto output017 = model->addOperand(&type6);
906 // Phase 2, operations
907 static int32_t param17_init[] = {0};
908 model->setOperandValue(param17, param17_init, sizeof(int32_t) * 1);
909 model->addOperation(ANEURALNETWORKS_SUB, {input017, input117, param17}, {output017});
910 // Phase 3, inputs and outputs
911 model->identifyInputsAndOutputs(
912 {input017, input117},
913 {output017});
914 assert(model->isValid());
915 }
916
is_ignored_dynamic_output_shape_18(int i)917 inline bool is_ignored_dynamic_output_shape_18(int i) {
918 static std::set<int> ignore = {};
919 return ignore.find(i) != ignore.end();
920 }
921
CreateModel_19(Model * model)922 void CreateModel_19(Model *model) {
923 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
924 OperandType type1(Type::INT32, {});
925 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
926 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
927 // Phase 1, operands
928 auto input018 = model->addOperand(&type2);
929 auto input118 = model->addOperand(&type0);
930 auto param18 = model->addOperand(&type1);
931 auto output018 = model->addOperand(&type3);
932 // Phase 2, operations
933 static int32_t param18_init[] = {0};
934 model->setOperandValue(param18, param18_init, sizeof(int32_t) * 1);
935 model->addOperation(ANEURALNETWORKS_SUB, {input018, input118, param18}, {output018});
936 // Phase 3, inputs and outputs
937 model->identifyInputsAndOutputs(
938 {input018, input118},
939 {output018});
940 assert(model->isValid());
941 }
942
is_ignored_19(int i)943 inline bool is_ignored_19(int i) {
944 static std::set<int> ignore = {};
945 return ignore.find(i) != ignore.end();
946 }
947
CreateModel_dynamic_output_shape_19(Model * model)948 void CreateModel_dynamic_output_shape_19(Model *model) {
949 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
950 OperandType type1(Type::INT32, {});
951 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
952 OperandType type7(Type::TENSOR_QUANT8_ASYMM, {0}, 0.01f, 120);
953 // Phase 1, operands
954 auto input018 = model->addOperand(&type2);
955 auto input118 = model->addOperand(&type0);
956 auto param18 = model->addOperand(&type1);
957 auto output018 = model->addOperand(&type7);
958 // Phase 2, operations
959 static int32_t param18_init[] = {0};
960 model->setOperandValue(param18, param18_init, sizeof(int32_t) * 1);
961 model->addOperation(ANEURALNETWORKS_SUB, {input018, input118, param18}, {output018});
962 // Phase 3, inputs and outputs
963 model->identifyInputsAndOutputs(
964 {input018, input118},
965 {output018});
966 assert(model->isValid());
967 }
968
is_ignored_dynamic_output_shape_19(int i)969 inline bool is_ignored_dynamic_output_shape_19(int i) {
970 static std::set<int> ignore = {};
971 return ignore.find(i) != ignore.end();
972 }
973
CreateModel_20(Model * model)974 void CreateModel_20(Model *model) {
975 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
976 OperandType type1(Type::INT32, {});
977 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
978 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
979 // Phase 1, operands
980 auto input019 = model->addOperand(&type2);
981 auto input119 = model->addOperand(&type0);
982 auto param19 = model->addOperand(&type1);
983 auto output019 = model->addOperand(&type4);
984 // Phase 2, operations
985 static int32_t param19_init[] = {0};
986 model->setOperandValue(param19, param19_init, sizeof(int32_t) * 1);
987 model->addOperation(ANEURALNETWORKS_SUB, {input019, input119, param19}, {output019});
988 // Phase 3, inputs and outputs
989 model->identifyInputsAndOutputs(
990 {input019, input119},
991 {output019});
992 assert(model->isValid());
993 }
994
is_ignored_20(int i)995 inline bool is_ignored_20(int i) {
996 static std::set<int> ignore = {};
997 return ignore.find(i) != ignore.end();
998 }
999
CreateModel_dynamic_output_shape_20(Model * model)1000 void CreateModel_dynamic_output_shape_20(Model *model) {
1001 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
1002 OperandType type1(Type::INT32, {});
1003 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
1004 OperandType type8(Type::TENSOR_QUANT8_ASYMM, {0}, 10.0f, 120);
1005 // Phase 1, operands
1006 auto input019 = model->addOperand(&type2);
1007 auto input119 = model->addOperand(&type0);
1008 auto param19 = model->addOperand(&type1);
1009 auto output019 = model->addOperand(&type8);
1010 // Phase 2, operations
1011 static int32_t param19_init[] = {0};
1012 model->setOperandValue(param19, param19_init, sizeof(int32_t) * 1);
1013 model->addOperation(ANEURALNETWORKS_SUB, {input019, input119, param19}, {output019});
1014 // Phase 3, inputs and outputs
1015 model->identifyInputsAndOutputs(
1016 {input019, input119},
1017 {output019});
1018 assert(model->isValid());
1019 }
1020
is_ignored_dynamic_output_shape_20(int i)1021 inline bool is_ignored_dynamic_output_shape_20(int i) {
1022 static std::set<int> ignore = {};
1023 return ignore.find(i) != ignore.end();
1024 }
1025
CreateModel_21(Model * model)1026 void CreateModel_21(Model *model) {
1027 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
1028 OperandType type1(Type::INT32, {});
1029 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
1030 // Phase 1, operands
1031 auto input020 = model->addOperand(&type2);
1032 auto input120 = model->addOperand(&type2);
1033 auto param20 = model->addOperand(&type1);
1034 auto output020 = model->addOperand(&type0);
1035 // Phase 2, operations
1036 static int32_t param20_init[] = {0};
1037 model->setOperandValue(param20, param20_init, sizeof(int32_t) * 1);
1038 model->addOperation(ANEURALNETWORKS_SUB, {input020, input120, param20}, {output020});
1039 // Phase 3, inputs and outputs
1040 model->identifyInputsAndOutputs(
1041 {input020, input120},
1042 {output020});
1043 assert(model->isValid());
1044 }
1045
is_ignored_21(int i)1046 inline bool is_ignored_21(int i) {
1047 static std::set<int> ignore = {};
1048 return ignore.find(i) != ignore.end();
1049 }
1050
CreateModel_dynamic_output_shape_21(Model * model)1051 void CreateModel_dynamic_output_shape_21(Model *model) {
1052 OperandType type1(Type::INT32, {});
1053 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
1054 OperandType type5(Type::TENSOR_QUANT8_ASYMM, {0}, 1.0f, 0);
1055 // Phase 1, operands
1056 auto input020 = model->addOperand(&type2);
1057 auto input120 = model->addOperand(&type2);
1058 auto param20 = model->addOperand(&type1);
1059 auto output020 = model->addOperand(&type5);
1060 // Phase 2, operations
1061 static int32_t param20_init[] = {0};
1062 model->setOperandValue(param20, param20_init, sizeof(int32_t) * 1);
1063 model->addOperation(ANEURALNETWORKS_SUB, {input020, input120, param20}, {output020});
1064 // Phase 3, inputs and outputs
1065 model->identifyInputsAndOutputs(
1066 {input020, input120},
1067 {output020});
1068 assert(model->isValid());
1069 }
1070
is_ignored_dynamic_output_shape_21(int i)1071 inline bool is_ignored_dynamic_output_shape_21(int i) {
1072 static std::set<int> ignore = {};
1073 return ignore.find(i) != ignore.end();
1074 }
1075
CreateModel_22(Model * model)1076 void CreateModel_22(Model *model) {
1077 OperandType type1(Type::INT32, {});
1078 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
1079 // Phase 1, operands
1080 auto input021 = model->addOperand(&type2);
1081 auto input121 = model->addOperand(&type2);
1082 auto param21 = model->addOperand(&type1);
1083 auto output021 = model->addOperand(&type2);
1084 // Phase 2, operations
1085 static int32_t param21_init[] = {0};
1086 model->setOperandValue(param21, param21_init, sizeof(int32_t) * 1);
1087 model->addOperation(ANEURALNETWORKS_SUB, {input021, input121, param21}, {output021});
1088 // Phase 3, inputs and outputs
1089 model->identifyInputsAndOutputs(
1090 {input021, input121},
1091 {output021});
1092 assert(model->isValid());
1093 }
1094
is_ignored_22(int i)1095 inline bool is_ignored_22(int i) {
1096 static std::set<int> ignore = {};
1097 return ignore.find(i) != ignore.end();
1098 }
1099
CreateModel_dynamic_output_shape_22(Model * model)1100 void CreateModel_dynamic_output_shape_22(Model *model) {
1101 OperandType type1(Type::INT32, {});
1102 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
1103 OperandType type6(Type::TENSOR_QUANT8_ASYMM, {0}, 1.0f, 1);
1104 // Phase 1, operands
1105 auto input021 = model->addOperand(&type2);
1106 auto input121 = model->addOperand(&type2);
1107 auto param21 = model->addOperand(&type1);
1108 auto output021 = model->addOperand(&type6);
1109 // Phase 2, operations
1110 static int32_t param21_init[] = {0};
1111 model->setOperandValue(param21, param21_init, sizeof(int32_t) * 1);
1112 model->addOperation(ANEURALNETWORKS_SUB, {input021, input121, param21}, {output021});
1113 // Phase 3, inputs and outputs
1114 model->identifyInputsAndOutputs(
1115 {input021, input121},
1116 {output021});
1117 assert(model->isValid());
1118 }
1119
is_ignored_dynamic_output_shape_22(int i)1120 inline bool is_ignored_dynamic_output_shape_22(int i) {
1121 static std::set<int> ignore = {};
1122 return ignore.find(i) != ignore.end();
1123 }
1124
CreateModel_23(Model * model)1125 void CreateModel_23(Model *model) {
1126 OperandType type1(Type::INT32, {});
1127 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
1128 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
1129 // Phase 1, operands
1130 auto input022 = model->addOperand(&type2);
1131 auto input122 = model->addOperand(&type2);
1132 auto param22 = model->addOperand(&type1);
1133 auto output022 = model->addOperand(&type3);
1134 // Phase 2, operations
1135 static int32_t param22_init[] = {0};
1136 model->setOperandValue(param22, param22_init, sizeof(int32_t) * 1);
1137 model->addOperation(ANEURALNETWORKS_SUB, {input022, input122, param22}, {output022});
1138 // Phase 3, inputs and outputs
1139 model->identifyInputsAndOutputs(
1140 {input022, input122},
1141 {output022});
1142 assert(model->isValid());
1143 }
1144
is_ignored_23(int i)1145 inline bool is_ignored_23(int i) {
1146 static std::set<int> ignore = {};
1147 return ignore.find(i) != ignore.end();
1148 }
1149
CreateModel_dynamic_output_shape_23(Model * model)1150 void CreateModel_dynamic_output_shape_23(Model *model) {
1151 OperandType type1(Type::INT32, {});
1152 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
1153 OperandType type7(Type::TENSOR_QUANT8_ASYMM, {0}, 0.01f, 120);
1154 // Phase 1, operands
1155 auto input022 = model->addOperand(&type2);
1156 auto input122 = model->addOperand(&type2);
1157 auto param22 = model->addOperand(&type1);
1158 auto output022 = model->addOperand(&type7);
1159 // Phase 2, operations
1160 static int32_t param22_init[] = {0};
1161 model->setOperandValue(param22, param22_init, sizeof(int32_t) * 1);
1162 model->addOperation(ANEURALNETWORKS_SUB, {input022, input122, param22}, {output022});
1163 // Phase 3, inputs and outputs
1164 model->identifyInputsAndOutputs(
1165 {input022, input122},
1166 {output022});
1167 assert(model->isValid());
1168 }
1169
is_ignored_dynamic_output_shape_23(int i)1170 inline bool is_ignored_dynamic_output_shape_23(int i) {
1171 static std::set<int> ignore = {};
1172 return ignore.find(i) != ignore.end();
1173 }
1174
CreateModel_24(Model * model)1175 void CreateModel_24(Model *model) {
1176 OperandType type1(Type::INT32, {});
1177 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
1178 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
1179 // Phase 1, operands
1180 auto input023 = model->addOperand(&type2);
1181 auto input123 = model->addOperand(&type2);
1182 auto param23 = model->addOperand(&type1);
1183 auto output023 = model->addOperand(&type4);
1184 // Phase 2, operations
1185 static int32_t param23_init[] = {0};
1186 model->setOperandValue(param23, param23_init, sizeof(int32_t) * 1);
1187 model->addOperation(ANEURALNETWORKS_SUB, {input023, input123, param23}, {output023});
1188 // Phase 3, inputs and outputs
1189 model->identifyInputsAndOutputs(
1190 {input023, input123},
1191 {output023});
1192 assert(model->isValid());
1193 }
1194
is_ignored_24(int i)1195 inline bool is_ignored_24(int i) {
1196 static std::set<int> ignore = {};
1197 return ignore.find(i) != ignore.end();
1198 }
1199
CreateModel_dynamic_output_shape_24(Model * model)1200 void CreateModel_dynamic_output_shape_24(Model *model) {
1201 OperandType type1(Type::INT32, {});
1202 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
1203 OperandType type8(Type::TENSOR_QUANT8_ASYMM, {0}, 10.0f, 120);
1204 // Phase 1, operands
1205 auto input023 = model->addOperand(&type2);
1206 auto input123 = model->addOperand(&type2);
1207 auto param23 = model->addOperand(&type1);
1208 auto output023 = model->addOperand(&type8);
1209 // Phase 2, operations
1210 static int32_t param23_init[] = {0};
1211 model->setOperandValue(param23, param23_init, sizeof(int32_t) * 1);
1212 model->addOperation(ANEURALNETWORKS_SUB, {input023, input123, param23}, {output023});
1213 // Phase 3, inputs and outputs
1214 model->identifyInputsAndOutputs(
1215 {input023, input123},
1216 {output023});
1217 assert(model->isValid());
1218 }
1219
is_ignored_dynamic_output_shape_24(int i)1220 inline bool is_ignored_dynamic_output_shape_24(int i) {
1221 static std::set<int> ignore = {};
1222 return ignore.find(i) != ignore.end();
1223 }
1224
CreateModel_25(Model * model)1225 void CreateModel_25(Model *model) {
1226 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
1227 OperandType type1(Type::INT32, {});
1228 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
1229 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
1230 // Phase 1, operands
1231 auto input024 = model->addOperand(&type2);
1232 auto input124 = model->addOperand(&type3);
1233 auto param24 = model->addOperand(&type1);
1234 auto output024 = model->addOperand(&type0);
1235 // Phase 2, operations
1236 static int32_t param24_init[] = {0};
1237 model->setOperandValue(param24, param24_init, sizeof(int32_t) * 1);
1238 model->addOperation(ANEURALNETWORKS_SUB, {input024, input124, param24}, {output024});
1239 // Phase 3, inputs and outputs
1240 model->identifyInputsAndOutputs(
1241 {input024, input124},
1242 {output024});
1243 assert(model->isValid());
1244 }
1245
is_ignored_25(int i)1246 inline bool is_ignored_25(int i) {
1247 static std::set<int> ignore = {};
1248 return ignore.find(i) != ignore.end();
1249 }
1250
CreateModel_dynamic_output_shape_25(Model * model)1251 void CreateModel_dynamic_output_shape_25(Model *model) {
1252 OperandType type1(Type::INT32, {});
1253 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
1254 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
1255 OperandType type5(Type::TENSOR_QUANT8_ASYMM, {0}, 1.0f, 0);
1256 // Phase 1, operands
1257 auto input024 = model->addOperand(&type2);
1258 auto input124 = model->addOperand(&type3);
1259 auto param24 = model->addOperand(&type1);
1260 auto output024 = model->addOperand(&type5);
1261 // Phase 2, operations
1262 static int32_t param24_init[] = {0};
1263 model->setOperandValue(param24, param24_init, sizeof(int32_t) * 1);
1264 model->addOperation(ANEURALNETWORKS_SUB, {input024, input124, param24}, {output024});
1265 // Phase 3, inputs and outputs
1266 model->identifyInputsAndOutputs(
1267 {input024, input124},
1268 {output024});
1269 assert(model->isValid());
1270 }
1271
is_ignored_dynamic_output_shape_25(int i)1272 inline bool is_ignored_dynamic_output_shape_25(int i) {
1273 static std::set<int> ignore = {};
1274 return ignore.find(i) != ignore.end();
1275 }
1276
CreateModel_26(Model * model)1277 void CreateModel_26(Model *model) {
1278 OperandType type1(Type::INT32, {});
1279 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
1280 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
1281 // Phase 1, operands
1282 auto input025 = model->addOperand(&type2);
1283 auto input125 = model->addOperand(&type3);
1284 auto param25 = model->addOperand(&type1);
1285 auto output025 = model->addOperand(&type2);
1286 // Phase 2, operations
1287 static int32_t param25_init[] = {0};
1288 model->setOperandValue(param25, param25_init, sizeof(int32_t) * 1);
1289 model->addOperation(ANEURALNETWORKS_SUB, {input025, input125, param25}, {output025});
1290 // Phase 3, inputs and outputs
1291 model->identifyInputsAndOutputs(
1292 {input025, input125},
1293 {output025});
1294 assert(model->isValid());
1295 }
1296
is_ignored_26(int i)1297 inline bool is_ignored_26(int i) {
1298 static std::set<int> ignore = {};
1299 return ignore.find(i) != ignore.end();
1300 }
1301
CreateModel_dynamic_output_shape_26(Model * model)1302 void CreateModel_dynamic_output_shape_26(Model *model) {
1303 OperandType type1(Type::INT32, {});
1304 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
1305 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
1306 OperandType type6(Type::TENSOR_QUANT8_ASYMM, {0}, 1.0f, 1);
1307 // Phase 1, operands
1308 auto input025 = model->addOperand(&type2);
1309 auto input125 = model->addOperand(&type3);
1310 auto param25 = model->addOperand(&type1);
1311 auto output025 = model->addOperand(&type6);
1312 // Phase 2, operations
1313 static int32_t param25_init[] = {0};
1314 model->setOperandValue(param25, param25_init, sizeof(int32_t) * 1);
1315 model->addOperation(ANEURALNETWORKS_SUB, {input025, input125, param25}, {output025});
1316 // Phase 3, inputs and outputs
1317 model->identifyInputsAndOutputs(
1318 {input025, input125},
1319 {output025});
1320 assert(model->isValid());
1321 }
1322
is_ignored_dynamic_output_shape_26(int i)1323 inline bool is_ignored_dynamic_output_shape_26(int i) {
1324 static std::set<int> ignore = {};
1325 return ignore.find(i) != ignore.end();
1326 }
1327
CreateModel_27(Model * model)1328 void CreateModel_27(Model *model) {
1329 OperandType type1(Type::INT32, {});
1330 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
1331 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
1332 // Phase 1, operands
1333 auto input026 = model->addOperand(&type2);
1334 auto input126 = model->addOperand(&type3);
1335 auto param26 = model->addOperand(&type1);
1336 auto output026 = model->addOperand(&type3);
1337 // Phase 2, operations
1338 static int32_t param26_init[] = {0};
1339 model->setOperandValue(param26, param26_init, sizeof(int32_t) * 1);
1340 model->addOperation(ANEURALNETWORKS_SUB, {input026, input126, param26}, {output026});
1341 // Phase 3, inputs and outputs
1342 model->identifyInputsAndOutputs(
1343 {input026, input126},
1344 {output026});
1345 assert(model->isValid());
1346 }
1347
is_ignored_27(int i)1348 inline bool is_ignored_27(int i) {
1349 static std::set<int> ignore = {};
1350 return ignore.find(i) != ignore.end();
1351 }
1352
CreateModel_dynamic_output_shape_27(Model * model)1353 void CreateModel_dynamic_output_shape_27(Model *model) {
1354 OperandType type1(Type::INT32, {});
1355 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
1356 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
1357 OperandType type7(Type::TENSOR_QUANT8_ASYMM, {0}, 0.01f, 120);
1358 // Phase 1, operands
1359 auto input026 = model->addOperand(&type2);
1360 auto input126 = model->addOperand(&type3);
1361 auto param26 = model->addOperand(&type1);
1362 auto output026 = model->addOperand(&type7);
1363 // Phase 2, operations
1364 static int32_t param26_init[] = {0};
1365 model->setOperandValue(param26, param26_init, sizeof(int32_t) * 1);
1366 model->addOperation(ANEURALNETWORKS_SUB, {input026, input126, param26}, {output026});
1367 // Phase 3, inputs and outputs
1368 model->identifyInputsAndOutputs(
1369 {input026, input126},
1370 {output026});
1371 assert(model->isValid());
1372 }
1373
is_ignored_dynamic_output_shape_27(int i)1374 inline bool is_ignored_dynamic_output_shape_27(int i) {
1375 static std::set<int> ignore = {};
1376 return ignore.find(i) != ignore.end();
1377 }
1378
CreateModel_28(Model * model)1379 void CreateModel_28(Model *model) {
1380 OperandType type1(Type::INT32, {});
1381 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
1382 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
1383 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
1384 // Phase 1, operands
1385 auto input027 = model->addOperand(&type2);
1386 auto input127 = model->addOperand(&type3);
1387 auto param27 = model->addOperand(&type1);
1388 auto output027 = model->addOperand(&type4);
1389 // Phase 2, operations
1390 static int32_t param27_init[] = {0};
1391 model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1);
1392 model->addOperation(ANEURALNETWORKS_SUB, {input027, input127, param27}, {output027});
1393 // Phase 3, inputs and outputs
1394 model->identifyInputsAndOutputs(
1395 {input027, input127},
1396 {output027});
1397 assert(model->isValid());
1398 }
1399
is_ignored_28(int i)1400 inline bool is_ignored_28(int i) {
1401 static std::set<int> ignore = {};
1402 return ignore.find(i) != ignore.end();
1403 }
1404
CreateModel_dynamic_output_shape_28(Model * model)1405 void CreateModel_dynamic_output_shape_28(Model *model) {
1406 OperandType type1(Type::INT32, {});
1407 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
1408 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
1409 OperandType type8(Type::TENSOR_QUANT8_ASYMM, {0}, 10.0f, 120);
1410 // Phase 1, operands
1411 auto input027 = model->addOperand(&type2);
1412 auto input127 = model->addOperand(&type3);
1413 auto param27 = model->addOperand(&type1);
1414 auto output027 = model->addOperand(&type8);
1415 // Phase 2, operations
1416 static int32_t param27_init[] = {0};
1417 model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1);
1418 model->addOperation(ANEURALNETWORKS_SUB, {input027, input127, param27}, {output027});
1419 // Phase 3, inputs and outputs
1420 model->identifyInputsAndOutputs(
1421 {input027, input127},
1422 {output027});
1423 assert(model->isValid());
1424 }
1425
is_ignored_dynamic_output_shape_28(int i)1426 inline bool is_ignored_dynamic_output_shape_28(int i) {
1427 static std::set<int> ignore = {};
1428 return ignore.find(i) != ignore.end();
1429 }
1430
CreateModel_29(Model * model)1431 void CreateModel_29(Model *model) {
1432 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
1433 OperandType type1(Type::INT32, {});
1434 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
1435 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
1436 // Phase 1, operands
1437 auto input028 = model->addOperand(&type2);
1438 auto input128 = model->addOperand(&type4);
1439 auto param28 = model->addOperand(&type1);
1440 auto output028 = model->addOperand(&type0);
1441 // Phase 2, operations
1442 static int32_t param28_init[] = {0};
1443 model->setOperandValue(param28, param28_init, sizeof(int32_t) * 1);
1444 model->addOperation(ANEURALNETWORKS_SUB, {input028, input128, param28}, {output028});
1445 // Phase 3, inputs and outputs
1446 model->identifyInputsAndOutputs(
1447 {input028, input128},
1448 {output028});
1449 assert(model->isValid());
1450 }
1451
is_ignored_29(int i)1452 inline bool is_ignored_29(int i) {
1453 static std::set<int> ignore = {};
1454 return ignore.find(i) != ignore.end();
1455 }
1456
CreateModel_dynamic_output_shape_29(Model * model)1457 void CreateModel_dynamic_output_shape_29(Model *model) {
1458 OperandType type1(Type::INT32, {});
1459 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
1460 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
1461 OperandType type5(Type::TENSOR_QUANT8_ASYMM, {0}, 1.0f, 0);
1462 // Phase 1, operands
1463 auto input028 = model->addOperand(&type2);
1464 auto input128 = model->addOperand(&type4);
1465 auto param28 = model->addOperand(&type1);
1466 auto output028 = model->addOperand(&type5);
1467 // Phase 2, operations
1468 static int32_t param28_init[] = {0};
1469 model->setOperandValue(param28, param28_init, sizeof(int32_t) * 1);
1470 model->addOperation(ANEURALNETWORKS_SUB, {input028, input128, param28}, {output028});
1471 // Phase 3, inputs and outputs
1472 model->identifyInputsAndOutputs(
1473 {input028, input128},
1474 {output028});
1475 assert(model->isValid());
1476 }
1477
is_ignored_dynamic_output_shape_29(int i)1478 inline bool is_ignored_dynamic_output_shape_29(int i) {
1479 static std::set<int> ignore = {};
1480 return ignore.find(i) != ignore.end();
1481 }
1482
CreateModel_30(Model * model)1483 void CreateModel_30(Model *model) {
1484 OperandType type1(Type::INT32, {});
1485 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
1486 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
1487 // Phase 1, operands
1488 auto input029 = model->addOperand(&type2);
1489 auto input129 = model->addOperand(&type4);
1490 auto param29 = model->addOperand(&type1);
1491 auto output029 = model->addOperand(&type2);
1492 // Phase 2, operations
1493 static int32_t param29_init[] = {0};
1494 model->setOperandValue(param29, param29_init, sizeof(int32_t) * 1);
1495 model->addOperation(ANEURALNETWORKS_SUB, {input029, input129, param29}, {output029});
1496 // Phase 3, inputs and outputs
1497 model->identifyInputsAndOutputs(
1498 {input029, input129},
1499 {output029});
1500 assert(model->isValid());
1501 }
1502
is_ignored_30(int i)1503 inline bool is_ignored_30(int i) {
1504 static std::set<int> ignore = {};
1505 return ignore.find(i) != ignore.end();
1506 }
1507
CreateModel_dynamic_output_shape_30(Model * model)1508 void CreateModel_dynamic_output_shape_30(Model *model) {
1509 OperandType type1(Type::INT32, {});
1510 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
1511 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
1512 OperandType type6(Type::TENSOR_QUANT8_ASYMM, {0}, 1.0f, 1);
1513 // Phase 1, operands
1514 auto input029 = model->addOperand(&type2);
1515 auto input129 = model->addOperand(&type4);
1516 auto param29 = model->addOperand(&type1);
1517 auto output029 = model->addOperand(&type6);
1518 // Phase 2, operations
1519 static int32_t param29_init[] = {0};
1520 model->setOperandValue(param29, param29_init, sizeof(int32_t) * 1);
1521 model->addOperation(ANEURALNETWORKS_SUB, {input029, input129, param29}, {output029});
1522 // Phase 3, inputs and outputs
1523 model->identifyInputsAndOutputs(
1524 {input029, input129},
1525 {output029});
1526 assert(model->isValid());
1527 }
1528
is_ignored_dynamic_output_shape_30(int i)1529 inline bool is_ignored_dynamic_output_shape_30(int i) {
1530 static std::set<int> ignore = {};
1531 return ignore.find(i) != ignore.end();
1532 }
1533
CreateModel_31(Model * model)1534 void CreateModel_31(Model *model) {
1535 OperandType type1(Type::INT32, {});
1536 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
1537 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
1538 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
1539 // Phase 1, operands
1540 auto input030 = model->addOperand(&type2);
1541 auto input130 = model->addOperand(&type4);
1542 auto param30 = model->addOperand(&type1);
1543 auto output030 = model->addOperand(&type3);
1544 // Phase 2, operations
1545 static int32_t param30_init[] = {0};
1546 model->setOperandValue(param30, param30_init, sizeof(int32_t) * 1);
1547 model->addOperation(ANEURALNETWORKS_SUB, {input030, input130, param30}, {output030});
1548 // Phase 3, inputs and outputs
1549 model->identifyInputsAndOutputs(
1550 {input030, input130},
1551 {output030});
1552 assert(model->isValid());
1553 }
1554
is_ignored_31(int i)1555 inline bool is_ignored_31(int i) {
1556 static std::set<int> ignore = {};
1557 return ignore.find(i) != ignore.end();
1558 }
1559
CreateModel_dynamic_output_shape_31(Model * model)1560 void CreateModel_dynamic_output_shape_31(Model *model) {
1561 OperandType type1(Type::INT32, {});
1562 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
1563 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
1564 OperandType type7(Type::TENSOR_QUANT8_ASYMM, {0}, 0.01f, 120);
1565 // Phase 1, operands
1566 auto input030 = model->addOperand(&type2);
1567 auto input130 = model->addOperand(&type4);
1568 auto param30 = model->addOperand(&type1);
1569 auto output030 = model->addOperand(&type7);
1570 // Phase 2, operations
1571 static int32_t param30_init[] = {0};
1572 model->setOperandValue(param30, param30_init, sizeof(int32_t) * 1);
1573 model->addOperation(ANEURALNETWORKS_SUB, {input030, input130, param30}, {output030});
1574 // Phase 3, inputs and outputs
1575 model->identifyInputsAndOutputs(
1576 {input030, input130},
1577 {output030});
1578 assert(model->isValid());
1579 }
1580
is_ignored_dynamic_output_shape_31(int i)1581 inline bool is_ignored_dynamic_output_shape_31(int i) {
1582 static std::set<int> ignore = {};
1583 return ignore.find(i) != ignore.end();
1584 }
1585
CreateModel_32(Model * model)1586 void CreateModel_32(Model *model) {
1587 OperandType type1(Type::INT32, {});
1588 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
1589 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
1590 // Phase 1, operands
1591 auto input031 = model->addOperand(&type2);
1592 auto input131 = model->addOperand(&type4);
1593 auto param31 = model->addOperand(&type1);
1594 auto output031 = model->addOperand(&type4);
1595 // Phase 2, operations
1596 static int32_t param31_init[] = {0};
1597 model->setOperandValue(param31, param31_init, sizeof(int32_t) * 1);
1598 model->addOperation(ANEURALNETWORKS_SUB, {input031, input131, param31}, {output031});
1599 // Phase 3, inputs and outputs
1600 model->identifyInputsAndOutputs(
1601 {input031, input131},
1602 {output031});
1603 assert(model->isValid());
1604 }
1605
is_ignored_32(int i)1606 inline bool is_ignored_32(int i) {
1607 static std::set<int> ignore = {};
1608 return ignore.find(i) != ignore.end();
1609 }
1610
CreateModel_dynamic_output_shape_32(Model * model)1611 void CreateModel_dynamic_output_shape_32(Model *model) {
1612 OperandType type1(Type::INT32, {});
1613 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
1614 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
1615 OperandType type8(Type::TENSOR_QUANT8_ASYMM, {0}, 10.0f, 120);
1616 // Phase 1, operands
1617 auto input031 = model->addOperand(&type2);
1618 auto input131 = model->addOperand(&type4);
1619 auto param31 = model->addOperand(&type1);
1620 auto output031 = model->addOperand(&type8);
1621 // Phase 2, operations
1622 static int32_t param31_init[] = {0};
1623 model->setOperandValue(param31, param31_init, sizeof(int32_t) * 1);
1624 model->addOperation(ANEURALNETWORKS_SUB, {input031, input131, param31}, {output031});
1625 // Phase 3, inputs and outputs
1626 model->identifyInputsAndOutputs(
1627 {input031, input131},
1628 {output031});
1629 assert(model->isValid());
1630 }
1631
is_ignored_dynamic_output_shape_32(int i)1632 inline bool is_ignored_dynamic_output_shape_32(int i) {
1633 static std::set<int> ignore = {};
1634 return ignore.find(i) != ignore.end();
1635 }
1636
CreateModel_33(Model * model)1637 void CreateModel_33(Model *model) {
1638 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
1639 OperandType type1(Type::INT32, {});
1640 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
1641 // Phase 1, operands
1642 auto input032 = model->addOperand(&type3);
1643 auto input132 = model->addOperand(&type0);
1644 auto param32 = model->addOperand(&type1);
1645 auto output032 = model->addOperand(&type0);
1646 // Phase 2, operations
1647 static int32_t param32_init[] = {0};
1648 model->setOperandValue(param32, param32_init, sizeof(int32_t) * 1);
1649 model->addOperation(ANEURALNETWORKS_SUB, {input032, input132, param32}, {output032});
1650 // Phase 3, inputs and outputs
1651 model->identifyInputsAndOutputs(
1652 {input032, input132},
1653 {output032});
1654 assert(model->isValid());
1655 }
1656
is_ignored_33(int i)1657 inline bool is_ignored_33(int i) {
1658 static std::set<int> ignore = {};
1659 return ignore.find(i) != ignore.end();
1660 }
1661
CreateModel_dynamic_output_shape_33(Model * model)1662 void CreateModel_dynamic_output_shape_33(Model *model) {
1663 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
1664 OperandType type1(Type::INT32, {});
1665 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
1666 OperandType type5(Type::TENSOR_QUANT8_ASYMM, {0}, 1.0f, 0);
1667 // Phase 1, operands
1668 auto input032 = model->addOperand(&type3);
1669 auto input132 = model->addOperand(&type0);
1670 auto param32 = model->addOperand(&type1);
1671 auto output032 = model->addOperand(&type5);
1672 // Phase 2, operations
1673 static int32_t param32_init[] = {0};
1674 model->setOperandValue(param32, param32_init, sizeof(int32_t) * 1);
1675 model->addOperation(ANEURALNETWORKS_SUB, {input032, input132, param32}, {output032});
1676 // Phase 3, inputs and outputs
1677 model->identifyInputsAndOutputs(
1678 {input032, input132},
1679 {output032});
1680 assert(model->isValid());
1681 }
1682
is_ignored_dynamic_output_shape_33(int i)1683 inline bool is_ignored_dynamic_output_shape_33(int i) {
1684 static std::set<int> ignore = {};
1685 return ignore.find(i) != ignore.end();
1686 }
1687
CreateModel_34(Model * model)1688 void CreateModel_34(Model *model) {
1689 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
1690 OperandType type1(Type::INT32, {});
1691 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
1692 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
1693 // Phase 1, operands
1694 auto input033 = model->addOperand(&type3);
1695 auto input133 = model->addOperand(&type0);
1696 auto param33 = model->addOperand(&type1);
1697 auto output033 = model->addOperand(&type2);
1698 // Phase 2, operations
1699 static int32_t param33_init[] = {0};
1700 model->setOperandValue(param33, param33_init, sizeof(int32_t) * 1);
1701 model->addOperation(ANEURALNETWORKS_SUB, {input033, input133, param33}, {output033});
1702 // Phase 3, inputs and outputs
1703 model->identifyInputsAndOutputs(
1704 {input033, input133},
1705 {output033});
1706 assert(model->isValid());
1707 }
1708
is_ignored_34(int i)1709 inline bool is_ignored_34(int i) {
1710 static std::set<int> ignore = {};
1711 return ignore.find(i) != ignore.end();
1712 }
1713
CreateModel_dynamic_output_shape_34(Model * model)1714 void CreateModel_dynamic_output_shape_34(Model *model) {
1715 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
1716 OperandType type1(Type::INT32, {});
1717 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
1718 OperandType type6(Type::TENSOR_QUANT8_ASYMM, {0}, 1.0f, 1);
1719 // Phase 1, operands
1720 auto input033 = model->addOperand(&type3);
1721 auto input133 = model->addOperand(&type0);
1722 auto param33 = model->addOperand(&type1);
1723 auto output033 = model->addOperand(&type6);
1724 // Phase 2, operations
1725 static int32_t param33_init[] = {0};
1726 model->setOperandValue(param33, param33_init, sizeof(int32_t) * 1);
1727 model->addOperation(ANEURALNETWORKS_SUB, {input033, input133, param33}, {output033});
1728 // Phase 3, inputs and outputs
1729 model->identifyInputsAndOutputs(
1730 {input033, input133},
1731 {output033});
1732 assert(model->isValid());
1733 }
1734
is_ignored_dynamic_output_shape_34(int i)1735 inline bool is_ignored_dynamic_output_shape_34(int i) {
1736 static std::set<int> ignore = {};
1737 return ignore.find(i) != ignore.end();
1738 }
1739
CreateModel_35(Model * model)1740 void CreateModel_35(Model *model) {
1741 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
1742 OperandType type1(Type::INT32, {});
1743 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
1744 // Phase 1, operands
1745 auto input034 = model->addOperand(&type3);
1746 auto input134 = model->addOperand(&type0);
1747 auto param34 = model->addOperand(&type1);
1748 auto output034 = model->addOperand(&type3);
1749 // Phase 2, operations
1750 static int32_t param34_init[] = {0};
1751 model->setOperandValue(param34, param34_init, sizeof(int32_t) * 1);
1752 model->addOperation(ANEURALNETWORKS_SUB, {input034, input134, param34}, {output034});
1753 // Phase 3, inputs and outputs
1754 model->identifyInputsAndOutputs(
1755 {input034, input134},
1756 {output034});
1757 assert(model->isValid());
1758 }
1759
is_ignored_35(int i)1760 inline bool is_ignored_35(int i) {
1761 static std::set<int> ignore = {};
1762 return ignore.find(i) != ignore.end();
1763 }
1764
CreateModel_dynamic_output_shape_35(Model * model)1765 void CreateModel_dynamic_output_shape_35(Model *model) {
1766 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
1767 OperandType type1(Type::INT32, {});
1768 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
1769 OperandType type7(Type::TENSOR_QUANT8_ASYMM, {0}, 0.01f, 120);
1770 // Phase 1, operands
1771 auto input034 = model->addOperand(&type3);
1772 auto input134 = model->addOperand(&type0);
1773 auto param34 = model->addOperand(&type1);
1774 auto output034 = model->addOperand(&type7);
1775 // Phase 2, operations
1776 static int32_t param34_init[] = {0};
1777 model->setOperandValue(param34, param34_init, sizeof(int32_t) * 1);
1778 model->addOperation(ANEURALNETWORKS_SUB, {input034, input134, param34}, {output034});
1779 // Phase 3, inputs and outputs
1780 model->identifyInputsAndOutputs(
1781 {input034, input134},
1782 {output034});
1783 assert(model->isValid());
1784 }
1785
is_ignored_dynamic_output_shape_35(int i)1786 inline bool is_ignored_dynamic_output_shape_35(int i) {
1787 static std::set<int> ignore = {};
1788 return ignore.find(i) != ignore.end();
1789 }
1790
CreateModel_36(Model * model)1791 void CreateModel_36(Model *model) {
1792 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
1793 OperandType type1(Type::INT32, {});
1794 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
1795 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
1796 // Phase 1, operands
1797 auto input035 = model->addOperand(&type3);
1798 auto input135 = model->addOperand(&type0);
1799 auto param35 = model->addOperand(&type1);
1800 auto output035 = model->addOperand(&type4);
1801 // Phase 2, operations
1802 static int32_t param35_init[] = {0};
1803 model->setOperandValue(param35, param35_init, sizeof(int32_t) * 1);
1804 model->addOperation(ANEURALNETWORKS_SUB, {input035, input135, param35}, {output035});
1805 // Phase 3, inputs and outputs
1806 model->identifyInputsAndOutputs(
1807 {input035, input135},
1808 {output035});
1809 assert(model->isValid());
1810 }
1811
is_ignored_36(int i)1812 inline bool is_ignored_36(int i) {
1813 static std::set<int> ignore = {};
1814 return ignore.find(i) != ignore.end();
1815 }
1816
CreateModel_dynamic_output_shape_36(Model * model)1817 void CreateModel_dynamic_output_shape_36(Model *model) {
1818 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
1819 OperandType type1(Type::INT32, {});
1820 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
1821 OperandType type8(Type::TENSOR_QUANT8_ASYMM, {0}, 10.0f, 120);
1822 // Phase 1, operands
1823 auto input035 = model->addOperand(&type3);
1824 auto input135 = model->addOperand(&type0);
1825 auto param35 = model->addOperand(&type1);
1826 auto output035 = model->addOperand(&type8);
1827 // Phase 2, operations
1828 static int32_t param35_init[] = {0};
1829 model->setOperandValue(param35, param35_init, sizeof(int32_t) * 1);
1830 model->addOperation(ANEURALNETWORKS_SUB, {input035, input135, param35}, {output035});
1831 // Phase 3, inputs and outputs
1832 model->identifyInputsAndOutputs(
1833 {input035, input135},
1834 {output035});
1835 assert(model->isValid());
1836 }
1837
is_ignored_dynamic_output_shape_36(int i)1838 inline bool is_ignored_dynamic_output_shape_36(int i) {
1839 static std::set<int> ignore = {};
1840 return ignore.find(i) != ignore.end();
1841 }
1842
CreateModel_37(Model * model)1843 void CreateModel_37(Model *model) {
1844 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
1845 OperandType type1(Type::INT32, {});
1846 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
1847 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
1848 // Phase 1, operands
1849 auto input036 = model->addOperand(&type3);
1850 auto input136 = model->addOperand(&type2);
1851 auto param36 = model->addOperand(&type1);
1852 auto output036 = model->addOperand(&type0);
1853 // Phase 2, operations
1854 static int32_t param36_init[] = {0};
1855 model->setOperandValue(param36, param36_init, sizeof(int32_t) * 1);
1856 model->addOperation(ANEURALNETWORKS_SUB, {input036, input136, param36}, {output036});
1857 // Phase 3, inputs and outputs
1858 model->identifyInputsAndOutputs(
1859 {input036, input136},
1860 {output036});
1861 assert(model->isValid());
1862 }
1863
is_ignored_37(int i)1864 inline bool is_ignored_37(int i) {
1865 static std::set<int> ignore = {};
1866 return ignore.find(i) != ignore.end();
1867 }
1868
CreateModel_dynamic_output_shape_37(Model * model)1869 void CreateModel_dynamic_output_shape_37(Model *model) {
1870 OperandType type1(Type::INT32, {});
1871 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
1872 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
1873 OperandType type5(Type::TENSOR_QUANT8_ASYMM, {0}, 1.0f, 0);
1874 // Phase 1, operands
1875 auto input036 = model->addOperand(&type3);
1876 auto input136 = model->addOperand(&type2);
1877 auto param36 = model->addOperand(&type1);
1878 auto output036 = model->addOperand(&type5);
1879 // Phase 2, operations
1880 static int32_t param36_init[] = {0};
1881 model->setOperandValue(param36, param36_init, sizeof(int32_t) * 1);
1882 model->addOperation(ANEURALNETWORKS_SUB, {input036, input136, param36}, {output036});
1883 // Phase 3, inputs and outputs
1884 model->identifyInputsAndOutputs(
1885 {input036, input136},
1886 {output036});
1887 assert(model->isValid());
1888 }
1889
is_ignored_dynamic_output_shape_37(int i)1890 inline bool is_ignored_dynamic_output_shape_37(int i) {
1891 static std::set<int> ignore = {};
1892 return ignore.find(i) != ignore.end();
1893 }
1894
CreateModel_38(Model * model)1895 void CreateModel_38(Model *model) {
1896 OperandType type1(Type::INT32, {});
1897 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
1898 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
1899 // Phase 1, operands
1900 auto input037 = model->addOperand(&type3);
1901 auto input137 = model->addOperand(&type2);
1902 auto param37 = model->addOperand(&type1);
1903 auto output037 = model->addOperand(&type2);
1904 // Phase 2, operations
1905 static int32_t param37_init[] = {0};
1906 model->setOperandValue(param37, param37_init, sizeof(int32_t) * 1);
1907 model->addOperation(ANEURALNETWORKS_SUB, {input037, input137, param37}, {output037});
1908 // Phase 3, inputs and outputs
1909 model->identifyInputsAndOutputs(
1910 {input037, input137},
1911 {output037});
1912 assert(model->isValid());
1913 }
1914
is_ignored_38(int i)1915 inline bool is_ignored_38(int i) {
1916 static std::set<int> ignore = {};
1917 return ignore.find(i) != ignore.end();
1918 }
1919
CreateModel_dynamic_output_shape_38(Model * model)1920 void CreateModel_dynamic_output_shape_38(Model *model) {
1921 OperandType type1(Type::INT32, {});
1922 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
1923 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
1924 OperandType type6(Type::TENSOR_QUANT8_ASYMM, {0}, 1.0f, 1);
1925 // Phase 1, operands
1926 auto input037 = model->addOperand(&type3);
1927 auto input137 = model->addOperand(&type2);
1928 auto param37 = model->addOperand(&type1);
1929 auto output037 = model->addOperand(&type6);
1930 // Phase 2, operations
1931 static int32_t param37_init[] = {0};
1932 model->setOperandValue(param37, param37_init, sizeof(int32_t) * 1);
1933 model->addOperation(ANEURALNETWORKS_SUB, {input037, input137, param37}, {output037});
1934 // Phase 3, inputs and outputs
1935 model->identifyInputsAndOutputs(
1936 {input037, input137},
1937 {output037});
1938 assert(model->isValid());
1939 }
1940
is_ignored_dynamic_output_shape_38(int i)1941 inline bool is_ignored_dynamic_output_shape_38(int i) {
1942 static std::set<int> ignore = {};
1943 return ignore.find(i) != ignore.end();
1944 }
1945
CreateModel_39(Model * model)1946 void CreateModel_39(Model *model) {
1947 OperandType type1(Type::INT32, {});
1948 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
1949 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
1950 // Phase 1, operands
1951 auto input038 = model->addOperand(&type3);
1952 auto input138 = model->addOperand(&type2);
1953 auto param38 = model->addOperand(&type1);
1954 auto output038 = model->addOperand(&type3);
1955 // Phase 2, operations
1956 static int32_t param38_init[] = {0};
1957 model->setOperandValue(param38, param38_init, sizeof(int32_t) * 1);
1958 model->addOperation(ANEURALNETWORKS_SUB, {input038, input138, param38}, {output038});
1959 // Phase 3, inputs and outputs
1960 model->identifyInputsAndOutputs(
1961 {input038, input138},
1962 {output038});
1963 assert(model->isValid());
1964 }
1965
is_ignored_39(int i)1966 inline bool is_ignored_39(int i) {
1967 static std::set<int> ignore = {};
1968 return ignore.find(i) != ignore.end();
1969 }
1970
CreateModel_dynamic_output_shape_39(Model * model)1971 void CreateModel_dynamic_output_shape_39(Model *model) {
1972 OperandType type1(Type::INT32, {});
1973 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
1974 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
1975 OperandType type7(Type::TENSOR_QUANT8_ASYMM, {0}, 0.01f, 120);
1976 // Phase 1, operands
1977 auto input038 = model->addOperand(&type3);
1978 auto input138 = model->addOperand(&type2);
1979 auto param38 = model->addOperand(&type1);
1980 auto output038 = model->addOperand(&type7);
1981 // Phase 2, operations
1982 static int32_t param38_init[] = {0};
1983 model->setOperandValue(param38, param38_init, sizeof(int32_t) * 1);
1984 model->addOperation(ANEURALNETWORKS_SUB, {input038, input138, param38}, {output038});
1985 // Phase 3, inputs and outputs
1986 model->identifyInputsAndOutputs(
1987 {input038, input138},
1988 {output038});
1989 assert(model->isValid());
1990 }
1991
is_ignored_dynamic_output_shape_39(int i)1992 inline bool is_ignored_dynamic_output_shape_39(int i) {
1993 static std::set<int> ignore = {};
1994 return ignore.find(i) != ignore.end();
1995 }
1996
CreateModel_40(Model * model)1997 void CreateModel_40(Model *model) {
1998 OperandType type1(Type::INT32, {});
1999 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
2000 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
2001 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
2002 // Phase 1, operands
2003 auto input039 = model->addOperand(&type3);
2004 auto input139 = model->addOperand(&type2);
2005 auto param39 = model->addOperand(&type1);
2006 auto output039 = model->addOperand(&type4);
2007 // Phase 2, operations
2008 static int32_t param39_init[] = {0};
2009 model->setOperandValue(param39, param39_init, sizeof(int32_t) * 1);
2010 model->addOperation(ANEURALNETWORKS_SUB, {input039, input139, param39}, {output039});
2011 // Phase 3, inputs and outputs
2012 model->identifyInputsAndOutputs(
2013 {input039, input139},
2014 {output039});
2015 assert(model->isValid());
2016 }
2017
is_ignored_40(int i)2018 inline bool is_ignored_40(int i) {
2019 static std::set<int> ignore = {};
2020 return ignore.find(i) != ignore.end();
2021 }
2022
CreateModel_dynamic_output_shape_40(Model * model)2023 void CreateModel_dynamic_output_shape_40(Model *model) {
2024 OperandType type1(Type::INT32, {});
2025 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
2026 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
2027 OperandType type8(Type::TENSOR_QUANT8_ASYMM, {0}, 10.0f, 120);
2028 // Phase 1, operands
2029 auto input039 = model->addOperand(&type3);
2030 auto input139 = model->addOperand(&type2);
2031 auto param39 = model->addOperand(&type1);
2032 auto output039 = model->addOperand(&type8);
2033 // Phase 2, operations
2034 static int32_t param39_init[] = {0};
2035 model->setOperandValue(param39, param39_init, sizeof(int32_t) * 1);
2036 model->addOperation(ANEURALNETWORKS_SUB, {input039, input139, param39}, {output039});
2037 // Phase 3, inputs and outputs
2038 model->identifyInputsAndOutputs(
2039 {input039, input139},
2040 {output039});
2041 assert(model->isValid());
2042 }
2043
is_ignored_dynamic_output_shape_40(int i)2044 inline bool is_ignored_dynamic_output_shape_40(int i) {
2045 static std::set<int> ignore = {};
2046 return ignore.find(i) != ignore.end();
2047 }
2048
CreateModel_41(Model * model)2049 void CreateModel_41(Model *model) {
2050 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
2051 OperandType type1(Type::INT32, {});
2052 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
2053 // Phase 1, operands
2054 auto input040 = model->addOperand(&type3);
2055 auto input140 = model->addOperand(&type3);
2056 auto param40 = model->addOperand(&type1);
2057 auto output040 = model->addOperand(&type0);
2058 // Phase 2, operations
2059 static int32_t param40_init[] = {0};
2060 model->setOperandValue(param40, param40_init, sizeof(int32_t) * 1);
2061 model->addOperation(ANEURALNETWORKS_SUB, {input040, input140, param40}, {output040});
2062 // Phase 3, inputs and outputs
2063 model->identifyInputsAndOutputs(
2064 {input040, input140},
2065 {output040});
2066 assert(model->isValid());
2067 }
2068
is_ignored_41(int i)2069 inline bool is_ignored_41(int i) {
2070 static std::set<int> ignore = {};
2071 return ignore.find(i) != ignore.end();
2072 }
2073
CreateModel_dynamic_output_shape_41(Model * model)2074 void CreateModel_dynamic_output_shape_41(Model *model) {
2075 OperandType type1(Type::INT32, {});
2076 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
2077 OperandType type5(Type::TENSOR_QUANT8_ASYMM, {0}, 1.0f, 0);
2078 // Phase 1, operands
2079 auto input040 = model->addOperand(&type3);
2080 auto input140 = model->addOperand(&type3);
2081 auto param40 = model->addOperand(&type1);
2082 auto output040 = model->addOperand(&type5);
2083 // Phase 2, operations
2084 static int32_t param40_init[] = {0};
2085 model->setOperandValue(param40, param40_init, sizeof(int32_t) * 1);
2086 model->addOperation(ANEURALNETWORKS_SUB, {input040, input140, param40}, {output040});
2087 // Phase 3, inputs and outputs
2088 model->identifyInputsAndOutputs(
2089 {input040, input140},
2090 {output040});
2091 assert(model->isValid());
2092 }
2093
is_ignored_dynamic_output_shape_41(int i)2094 inline bool is_ignored_dynamic_output_shape_41(int i) {
2095 static std::set<int> ignore = {};
2096 return ignore.find(i) != ignore.end();
2097 }
2098
CreateModel_42(Model * model)2099 void CreateModel_42(Model *model) {
2100 OperandType type1(Type::INT32, {});
2101 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
2102 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
2103 // Phase 1, operands
2104 auto input041 = model->addOperand(&type3);
2105 auto input141 = model->addOperand(&type3);
2106 auto param41 = model->addOperand(&type1);
2107 auto output041 = model->addOperand(&type2);
2108 // Phase 2, operations
2109 static int32_t param41_init[] = {0};
2110 model->setOperandValue(param41, param41_init, sizeof(int32_t) * 1);
2111 model->addOperation(ANEURALNETWORKS_SUB, {input041, input141, param41}, {output041});
2112 // Phase 3, inputs and outputs
2113 model->identifyInputsAndOutputs(
2114 {input041, input141},
2115 {output041});
2116 assert(model->isValid());
2117 }
2118
is_ignored_42(int i)2119 inline bool is_ignored_42(int i) {
2120 static std::set<int> ignore = {};
2121 return ignore.find(i) != ignore.end();
2122 }
2123
CreateModel_dynamic_output_shape_42(Model * model)2124 void CreateModel_dynamic_output_shape_42(Model *model) {
2125 OperandType type1(Type::INT32, {});
2126 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
2127 OperandType type6(Type::TENSOR_QUANT8_ASYMM, {0}, 1.0f, 1);
2128 // Phase 1, operands
2129 auto input041 = model->addOperand(&type3);
2130 auto input141 = model->addOperand(&type3);
2131 auto param41 = model->addOperand(&type1);
2132 auto output041 = model->addOperand(&type6);
2133 // Phase 2, operations
2134 static int32_t param41_init[] = {0};
2135 model->setOperandValue(param41, param41_init, sizeof(int32_t) * 1);
2136 model->addOperation(ANEURALNETWORKS_SUB, {input041, input141, param41}, {output041});
2137 // Phase 3, inputs and outputs
2138 model->identifyInputsAndOutputs(
2139 {input041, input141},
2140 {output041});
2141 assert(model->isValid());
2142 }
2143
is_ignored_dynamic_output_shape_42(int i)2144 inline bool is_ignored_dynamic_output_shape_42(int i) {
2145 static std::set<int> ignore = {};
2146 return ignore.find(i) != ignore.end();
2147 }
2148
CreateModel_43(Model * model)2149 void CreateModel_43(Model *model) {
2150 OperandType type1(Type::INT32, {});
2151 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
2152 // Phase 1, operands
2153 auto input042 = model->addOperand(&type3);
2154 auto input142 = model->addOperand(&type3);
2155 auto param42 = model->addOperand(&type1);
2156 auto output042 = model->addOperand(&type3);
2157 // Phase 2, operations
2158 static int32_t param42_init[] = {0};
2159 model->setOperandValue(param42, param42_init, sizeof(int32_t) * 1);
2160 model->addOperation(ANEURALNETWORKS_SUB, {input042, input142, param42}, {output042});
2161 // Phase 3, inputs and outputs
2162 model->identifyInputsAndOutputs(
2163 {input042, input142},
2164 {output042});
2165 assert(model->isValid());
2166 }
2167
is_ignored_43(int i)2168 inline bool is_ignored_43(int i) {
2169 static std::set<int> ignore = {};
2170 return ignore.find(i) != ignore.end();
2171 }
2172
CreateModel_dynamic_output_shape_43(Model * model)2173 void CreateModel_dynamic_output_shape_43(Model *model) {
2174 OperandType type1(Type::INT32, {});
2175 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
2176 OperandType type7(Type::TENSOR_QUANT8_ASYMM, {0}, 0.01f, 120);
2177 // Phase 1, operands
2178 auto input042 = model->addOperand(&type3);
2179 auto input142 = model->addOperand(&type3);
2180 auto param42 = model->addOperand(&type1);
2181 auto output042 = model->addOperand(&type7);
2182 // Phase 2, operations
2183 static int32_t param42_init[] = {0};
2184 model->setOperandValue(param42, param42_init, sizeof(int32_t) * 1);
2185 model->addOperation(ANEURALNETWORKS_SUB, {input042, input142, param42}, {output042});
2186 // Phase 3, inputs and outputs
2187 model->identifyInputsAndOutputs(
2188 {input042, input142},
2189 {output042});
2190 assert(model->isValid());
2191 }
2192
is_ignored_dynamic_output_shape_43(int i)2193 inline bool is_ignored_dynamic_output_shape_43(int i) {
2194 static std::set<int> ignore = {};
2195 return ignore.find(i) != ignore.end();
2196 }
2197
CreateModel_44(Model * model)2198 void CreateModel_44(Model *model) {
2199 OperandType type1(Type::INT32, {});
2200 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
2201 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
2202 // Phase 1, operands
2203 auto input043 = model->addOperand(&type3);
2204 auto input143 = model->addOperand(&type3);
2205 auto param43 = model->addOperand(&type1);
2206 auto output043 = model->addOperand(&type4);
2207 // Phase 2, operations
2208 static int32_t param43_init[] = {0};
2209 model->setOperandValue(param43, param43_init, sizeof(int32_t) * 1);
2210 model->addOperation(ANEURALNETWORKS_SUB, {input043, input143, param43}, {output043});
2211 // Phase 3, inputs and outputs
2212 model->identifyInputsAndOutputs(
2213 {input043, input143},
2214 {output043});
2215 assert(model->isValid());
2216 }
2217
is_ignored_44(int i)2218 inline bool is_ignored_44(int i) {
2219 static std::set<int> ignore = {};
2220 return ignore.find(i) != ignore.end();
2221 }
2222
CreateModel_dynamic_output_shape_44(Model * model)2223 void CreateModel_dynamic_output_shape_44(Model *model) {
2224 OperandType type1(Type::INT32, {});
2225 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
2226 OperandType type8(Type::TENSOR_QUANT8_ASYMM, {0}, 10.0f, 120);
2227 // Phase 1, operands
2228 auto input043 = model->addOperand(&type3);
2229 auto input143 = model->addOperand(&type3);
2230 auto param43 = model->addOperand(&type1);
2231 auto output043 = model->addOperand(&type8);
2232 // Phase 2, operations
2233 static int32_t param43_init[] = {0};
2234 model->setOperandValue(param43, param43_init, sizeof(int32_t) * 1);
2235 model->addOperation(ANEURALNETWORKS_SUB, {input043, input143, param43}, {output043});
2236 // Phase 3, inputs and outputs
2237 model->identifyInputsAndOutputs(
2238 {input043, input143},
2239 {output043});
2240 assert(model->isValid());
2241 }
2242
is_ignored_dynamic_output_shape_44(int i)2243 inline bool is_ignored_dynamic_output_shape_44(int i) {
2244 static std::set<int> ignore = {};
2245 return ignore.find(i) != ignore.end();
2246 }
2247
CreateModel_45(Model * model)2248 void CreateModel_45(Model *model) {
2249 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
2250 OperandType type1(Type::INT32, {});
2251 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
2252 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
2253 // Phase 1, operands
2254 auto input044 = model->addOperand(&type3);
2255 auto input144 = model->addOperand(&type4);
2256 auto param44 = model->addOperand(&type1);
2257 auto output044 = model->addOperand(&type0);
2258 // Phase 2, operations
2259 static int32_t param44_init[] = {0};
2260 model->setOperandValue(param44, param44_init, sizeof(int32_t) * 1);
2261 model->addOperation(ANEURALNETWORKS_SUB, {input044, input144, param44}, {output044});
2262 // Phase 3, inputs and outputs
2263 model->identifyInputsAndOutputs(
2264 {input044, input144},
2265 {output044});
2266 assert(model->isValid());
2267 }
2268
is_ignored_45(int i)2269 inline bool is_ignored_45(int i) {
2270 static std::set<int> ignore = {};
2271 return ignore.find(i) != ignore.end();
2272 }
2273
CreateModel_dynamic_output_shape_45(Model * model)2274 void CreateModel_dynamic_output_shape_45(Model *model) {
2275 OperandType type1(Type::INT32, {});
2276 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
2277 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
2278 OperandType type5(Type::TENSOR_QUANT8_ASYMM, {0}, 1.0f, 0);
2279 // Phase 1, operands
2280 auto input044 = model->addOperand(&type3);
2281 auto input144 = model->addOperand(&type4);
2282 auto param44 = model->addOperand(&type1);
2283 auto output044 = model->addOperand(&type5);
2284 // Phase 2, operations
2285 static int32_t param44_init[] = {0};
2286 model->setOperandValue(param44, param44_init, sizeof(int32_t) * 1);
2287 model->addOperation(ANEURALNETWORKS_SUB, {input044, input144, param44}, {output044});
2288 // Phase 3, inputs and outputs
2289 model->identifyInputsAndOutputs(
2290 {input044, input144},
2291 {output044});
2292 assert(model->isValid());
2293 }
2294
is_ignored_dynamic_output_shape_45(int i)2295 inline bool is_ignored_dynamic_output_shape_45(int i) {
2296 static std::set<int> ignore = {};
2297 return ignore.find(i) != ignore.end();
2298 }
2299
CreateModel_46(Model * model)2300 void CreateModel_46(Model *model) {
2301 OperandType type1(Type::INT32, {});
2302 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
2303 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
2304 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
2305 // Phase 1, operands
2306 auto input045 = model->addOperand(&type3);
2307 auto input145 = model->addOperand(&type4);
2308 auto param45 = model->addOperand(&type1);
2309 auto output045 = model->addOperand(&type2);
2310 // Phase 2, operations
2311 static int32_t param45_init[] = {0};
2312 model->setOperandValue(param45, param45_init, sizeof(int32_t) * 1);
2313 model->addOperation(ANEURALNETWORKS_SUB, {input045, input145, param45}, {output045});
2314 // Phase 3, inputs and outputs
2315 model->identifyInputsAndOutputs(
2316 {input045, input145},
2317 {output045});
2318 assert(model->isValid());
2319 }
2320
is_ignored_46(int i)2321 inline bool is_ignored_46(int i) {
2322 static std::set<int> ignore = {};
2323 return ignore.find(i) != ignore.end();
2324 }
2325
CreateModel_dynamic_output_shape_46(Model * model)2326 void CreateModel_dynamic_output_shape_46(Model *model) {
2327 OperandType type1(Type::INT32, {});
2328 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
2329 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
2330 OperandType type6(Type::TENSOR_QUANT8_ASYMM, {0}, 1.0f, 1);
2331 // Phase 1, operands
2332 auto input045 = model->addOperand(&type3);
2333 auto input145 = model->addOperand(&type4);
2334 auto param45 = model->addOperand(&type1);
2335 auto output045 = model->addOperand(&type6);
2336 // Phase 2, operations
2337 static int32_t param45_init[] = {0};
2338 model->setOperandValue(param45, param45_init, sizeof(int32_t) * 1);
2339 model->addOperation(ANEURALNETWORKS_SUB, {input045, input145, param45}, {output045});
2340 // Phase 3, inputs and outputs
2341 model->identifyInputsAndOutputs(
2342 {input045, input145},
2343 {output045});
2344 assert(model->isValid());
2345 }
2346
is_ignored_dynamic_output_shape_46(int i)2347 inline bool is_ignored_dynamic_output_shape_46(int i) {
2348 static std::set<int> ignore = {};
2349 return ignore.find(i) != ignore.end();
2350 }
2351
CreateModel_47(Model * model)2352 void CreateModel_47(Model *model) {
2353 OperandType type1(Type::INT32, {});
2354 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
2355 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
2356 // Phase 1, operands
2357 auto input046 = model->addOperand(&type3);
2358 auto input146 = model->addOperand(&type4);
2359 auto param46 = model->addOperand(&type1);
2360 auto output046 = model->addOperand(&type3);
2361 // Phase 2, operations
2362 static int32_t param46_init[] = {0};
2363 model->setOperandValue(param46, param46_init, sizeof(int32_t) * 1);
2364 model->addOperation(ANEURALNETWORKS_SUB, {input046, input146, param46}, {output046});
2365 // Phase 3, inputs and outputs
2366 model->identifyInputsAndOutputs(
2367 {input046, input146},
2368 {output046});
2369 assert(model->isValid());
2370 }
2371
is_ignored_47(int i)2372 inline bool is_ignored_47(int i) {
2373 static std::set<int> ignore = {};
2374 return ignore.find(i) != ignore.end();
2375 }
2376
CreateModel_dynamic_output_shape_47(Model * model)2377 void CreateModel_dynamic_output_shape_47(Model *model) {
2378 OperandType type1(Type::INT32, {});
2379 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
2380 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
2381 OperandType type7(Type::TENSOR_QUANT8_ASYMM, {0}, 0.01f, 120);
2382 // Phase 1, operands
2383 auto input046 = model->addOperand(&type3);
2384 auto input146 = model->addOperand(&type4);
2385 auto param46 = model->addOperand(&type1);
2386 auto output046 = model->addOperand(&type7);
2387 // Phase 2, operations
2388 static int32_t param46_init[] = {0};
2389 model->setOperandValue(param46, param46_init, sizeof(int32_t) * 1);
2390 model->addOperation(ANEURALNETWORKS_SUB, {input046, input146, param46}, {output046});
2391 // Phase 3, inputs and outputs
2392 model->identifyInputsAndOutputs(
2393 {input046, input146},
2394 {output046});
2395 assert(model->isValid());
2396 }
2397
is_ignored_dynamic_output_shape_47(int i)2398 inline bool is_ignored_dynamic_output_shape_47(int i) {
2399 static std::set<int> ignore = {};
2400 return ignore.find(i) != ignore.end();
2401 }
2402
CreateModel_48(Model * model)2403 void CreateModel_48(Model *model) {
2404 OperandType type1(Type::INT32, {});
2405 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
2406 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
2407 // Phase 1, operands
2408 auto input047 = model->addOperand(&type3);
2409 auto input147 = model->addOperand(&type4);
2410 auto param47 = model->addOperand(&type1);
2411 auto output047 = model->addOperand(&type4);
2412 // Phase 2, operations
2413 static int32_t param47_init[] = {0};
2414 model->setOperandValue(param47, param47_init, sizeof(int32_t) * 1);
2415 model->addOperation(ANEURALNETWORKS_SUB, {input047, input147, param47}, {output047});
2416 // Phase 3, inputs and outputs
2417 model->identifyInputsAndOutputs(
2418 {input047, input147},
2419 {output047});
2420 assert(model->isValid());
2421 }
2422
is_ignored_48(int i)2423 inline bool is_ignored_48(int i) {
2424 static std::set<int> ignore = {};
2425 return ignore.find(i) != ignore.end();
2426 }
2427
CreateModel_dynamic_output_shape_48(Model * model)2428 void CreateModel_dynamic_output_shape_48(Model *model) {
2429 OperandType type1(Type::INT32, {});
2430 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
2431 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
2432 OperandType type8(Type::TENSOR_QUANT8_ASYMM, {0}, 10.0f, 120);
2433 // Phase 1, operands
2434 auto input047 = model->addOperand(&type3);
2435 auto input147 = model->addOperand(&type4);
2436 auto param47 = model->addOperand(&type1);
2437 auto output047 = model->addOperand(&type8);
2438 // Phase 2, operations
2439 static int32_t param47_init[] = {0};
2440 model->setOperandValue(param47, param47_init, sizeof(int32_t) * 1);
2441 model->addOperation(ANEURALNETWORKS_SUB, {input047, input147, param47}, {output047});
2442 // Phase 3, inputs and outputs
2443 model->identifyInputsAndOutputs(
2444 {input047, input147},
2445 {output047});
2446 assert(model->isValid());
2447 }
2448
is_ignored_dynamic_output_shape_48(int i)2449 inline bool is_ignored_dynamic_output_shape_48(int i) {
2450 static std::set<int> ignore = {};
2451 return ignore.find(i) != ignore.end();
2452 }
2453
CreateModel_49(Model * model)2454 void CreateModel_49(Model *model) {
2455 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
2456 OperandType type1(Type::INT32, {});
2457 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
2458 // Phase 1, operands
2459 auto input048 = model->addOperand(&type4);
2460 auto input148 = model->addOperand(&type0);
2461 auto param48 = model->addOperand(&type1);
2462 auto output048 = model->addOperand(&type0);
2463 // Phase 2, operations
2464 static int32_t param48_init[] = {0};
2465 model->setOperandValue(param48, param48_init, sizeof(int32_t) * 1);
2466 model->addOperation(ANEURALNETWORKS_SUB, {input048, input148, param48}, {output048});
2467 // Phase 3, inputs and outputs
2468 model->identifyInputsAndOutputs(
2469 {input048, input148},
2470 {output048});
2471 assert(model->isValid());
2472 }
2473
is_ignored_49(int i)2474 inline bool is_ignored_49(int i) {
2475 static std::set<int> ignore = {};
2476 return ignore.find(i) != ignore.end();
2477 }
2478
CreateModel_dynamic_output_shape_49(Model * model)2479 void CreateModel_dynamic_output_shape_49(Model *model) {
2480 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
2481 OperandType type1(Type::INT32, {});
2482 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
2483 OperandType type5(Type::TENSOR_QUANT8_ASYMM, {0}, 1.0f, 0);
2484 // Phase 1, operands
2485 auto input048 = model->addOperand(&type4);
2486 auto input148 = model->addOperand(&type0);
2487 auto param48 = model->addOperand(&type1);
2488 auto output048 = model->addOperand(&type5);
2489 // Phase 2, operations
2490 static int32_t param48_init[] = {0};
2491 model->setOperandValue(param48, param48_init, sizeof(int32_t) * 1);
2492 model->addOperation(ANEURALNETWORKS_SUB, {input048, input148, param48}, {output048});
2493 // Phase 3, inputs and outputs
2494 model->identifyInputsAndOutputs(
2495 {input048, input148},
2496 {output048});
2497 assert(model->isValid());
2498 }
2499
is_ignored_dynamic_output_shape_49(int i)2500 inline bool is_ignored_dynamic_output_shape_49(int i) {
2501 static std::set<int> ignore = {};
2502 return ignore.find(i) != ignore.end();
2503 }
2504
CreateModel_50(Model * model)2505 void CreateModel_50(Model *model) {
2506 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
2507 OperandType type1(Type::INT32, {});
2508 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
2509 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
2510 // Phase 1, operands
2511 auto input049 = model->addOperand(&type4);
2512 auto input149 = model->addOperand(&type0);
2513 auto param49 = model->addOperand(&type1);
2514 auto output049 = model->addOperand(&type2);
2515 // Phase 2, operations
2516 static int32_t param49_init[] = {0};
2517 model->setOperandValue(param49, param49_init, sizeof(int32_t) * 1);
2518 model->addOperation(ANEURALNETWORKS_SUB, {input049, input149, param49}, {output049});
2519 // Phase 3, inputs and outputs
2520 model->identifyInputsAndOutputs(
2521 {input049, input149},
2522 {output049});
2523 assert(model->isValid());
2524 }
2525
is_ignored_50(int i)2526 inline bool is_ignored_50(int i) {
2527 static std::set<int> ignore = {};
2528 return ignore.find(i) != ignore.end();
2529 }
2530
CreateModel_dynamic_output_shape_50(Model * model)2531 void CreateModel_dynamic_output_shape_50(Model *model) {
2532 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
2533 OperandType type1(Type::INT32, {});
2534 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
2535 OperandType type6(Type::TENSOR_QUANT8_ASYMM, {0}, 1.0f, 1);
2536 // Phase 1, operands
2537 auto input049 = model->addOperand(&type4);
2538 auto input149 = model->addOperand(&type0);
2539 auto param49 = model->addOperand(&type1);
2540 auto output049 = model->addOperand(&type6);
2541 // Phase 2, operations
2542 static int32_t param49_init[] = {0};
2543 model->setOperandValue(param49, param49_init, sizeof(int32_t) * 1);
2544 model->addOperation(ANEURALNETWORKS_SUB, {input049, input149, param49}, {output049});
2545 // Phase 3, inputs and outputs
2546 model->identifyInputsAndOutputs(
2547 {input049, input149},
2548 {output049});
2549 assert(model->isValid());
2550 }
2551
is_ignored_dynamic_output_shape_50(int i)2552 inline bool is_ignored_dynamic_output_shape_50(int i) {
2553 static std::set<int> ignore = {};
2554 return ignore.find(i) != ignore.end();
2555 }
2556
CreateModel_51(Model * model)2557 void CreateModel_51(Model *model) {
2558 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
2559 OperandType type1(Type::INT32, {});
2560 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
2561 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
2562 // Phase 1, operands
2563 auto input050 = model->addOperand(&type4);
2564 auto input150 = model->addOperand(&type0);
2565 auto param50 = model->addOperand(&type1);
2566 auto output050 = model->addOperand(&type3);
2567 // Phase 2, operations
2568 static int32_t param50_init[] = {0};
2569 model->setOperandValue(param50, param50_init, sizeof(int32_t) * 1);
2570 model->addOperation(ANEURALNETWORKS_SUB, {input050, input150, param50}, {output050});
2571 // Phase 3, inputs and outputs
2572 model->identifyInputsAndOutputs(
2573 {input050, input150},
2574 {output050});
2575 assert(model->isValid());
2576 }
2577
is_ignored_51(int i)2578 inline bool is_ignored_51(int i) {
2579 static std::set<int> ignore = {};
2580 return ignore.find(i) != ignore.end();
2581 }
2582
CreateModel_dynamic_output_shape_51(Model * model)2583 void CreateModel_dynamic_output_shape_51(Model *model) {
2584 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
2585 OperandType type1(Type::INT32, {});
2586 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
2587 OperandType type7(Type::TENSOR_QUANT8_ASYMM, {0}, 0.01f, 120);
2588 // Phase 1, operands
2589 auto input050 = model->addOperand(&type4);
2590 auto input150 = model->addOperand(&type0);
2591 auto param50 = model->addOperand(&type1);
2592 auto output050 = model->addOperand(&type7);
2593 // Phase 2, operations
2594 static int32_t param50_init[] = {0};
2595 model->setOperandValue(param50, param50_init, sizeof(int32_t) * 1);
2596 model->addOperation(ANEURALNETWORKS_SUB, {input050, input150, param50}, {output050});
2597 // Phase 3, inputs and outputs
2598 model->identifyInputsAndOutputs(
2599 {input050, input150},
2600 {output050});
2601 assert(model->isValid());
2602 }
2603
is_ignored_dynamic_output_shape_51(int i)2604 inline bool is_ignored_dynamic_output_shape_51(int i) {
2605 static std::set<int> ignore = {};
2606 return ignore.find(i) != ignore.end();
2607 }
2608
CreateModel_52(Model * model)2609 void CreateModel_52(Model *model) {
2610 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
2611 OperandType type1(Type::INT32, {});
2612 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
2613 // Phase 1, operands
2614 auto input051 = model->addOperand(&type4);
2615 auto input151 = model->addOperand(&type0);
2616 auto param51 = model->addOperand(&type1);
2617 auto output051 = model->addOperand(&type4);
2618 // Phase 2, operations
2619 static int32_t param51_init[] = {0};
2620 model->setOperandValue(param51, param51_init, sizeof(int32_t) * 1);
2621 model->addOperation(ANEURALNETWORKS_SUB, {input051, input151, param51}, {output051});
2622 // Phase 3, inputs and outputs
2623 model->identifyInputsAndOutputs(
2624 {input051, input151},
2625 {output051});
2626 assert(model->isValid());
2627 }
2628
is_ignored_52(int i)2629 inline bool is_ignored_52(int i) {
2630 static std::set<int> ignore = {};
2631 return ignore.find(i) != ignore.end();
2632 }
2633
CreateModel_dynamic_output_shape_52(Model * model)2634 void CreateModel_dynamic_output_shape_52(Model *model) {
2635 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
2636 OperandType type1(Type::INT32, {});
2637 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
2638 OperandType type8(Type::TENSOR_QUANT8_ASYMM, {0}, 10.0f, 120);
2639 // Phase 1, operands
2640 auto input051 = model->addOperand(&type4);
2641 auto input151 = model->addOperand(&type0);
2642 auto param51 = model->addOperand(&type1);
2643 auto output051 = model->addOperand(&type8);
2644 // Phase 2, operations
2645 static int32_t param51_init[] = {0};
2646 model->setOperandValue(param51, param51_init, sizeof(int32_t) * 1);
2647 model->addOperation(ANEURALNETWORKS_SUB, {input051, input151, param51}, {output051});
2648 // Phase 3, inputs and outputs
2649 model->identifyInputsAndOutputs(
2650 {input051, input151},
2651 {output051});
2652 assert(model->isValid());
2653 }
2654
is_ignored_dynamic_output_shape_52(int i)2655 inline bool is_ignored_dynamic_output_shape_52(int i) {
2656 static std::set<int> ignore = {};
2657 return ignore.find(i) != ignore.end();
2658 }
2659
CreateModel_53(Model * model)2660 void CreateModel_53(Model *model) {
2661 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
2662 OperandType type1(Type::INT32, {});
2663 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
2664 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
2665 // Phase 1, operands
2666 auto input052 = model->addOperand(&type4);
2667 auto input152 = model->addOperand(&type2);
2668 auto param52 = model->addOperand(&type1);
2669 auto output052 = model->addOperand(&type0);
2670 // Phase 2, operations
2671 static int32_t param52_init[] = {0};
2672 model->setOperandValue(param52, param52_init, sizeof(int32_t) * 1);
2673 model->addOperation(ANEURALNETWORKS_SUB, {input052, input152, param52}, {output052});
2674 // Phase 3, inputs and outputs
2675 model->identifyInputsAndOutputs(
2676 {input052, input152},
2677 {output052});
2678 assert(model->isValid());
2679 }
2680
is_ignored_53(int i)2681 inline bool is_ignored_53(int i) {
2682 static std::set<int> ignore = {};
2683 return ignore.find(i) != ignore.end();
2684 }
2685
CreateModel_dynamic_output_shape_53(Model * model)2686 void CreateModel_dynamic_output_shape_53(Model *model) {
2687 OperandType type1(Type::INT32, {});
2688 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
2689 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
2690 OperandType type5(Type::TENSOR_QUANT8_ASYMM, {0}, 1.0f, 0);
2691 // Phase 1, operands
2692 auto input052 = model->addOperand(&type4);
2693 auto input152 = model->addOperand(&type2);
2694 auto param52 = model->addOperand(&type1);
2695 auto output052 = model->addOperand(&type5);
2696 // Phase 2, operations
2697 static int32_t param52_init[] = {0};
2698 model->setOperandValue(param52, param52_init, sizeof(int32_t) * 1);
2699 model->addOperation(ANEURALNETWORKS_SUB, {input052, input152, param52}, {output052});
2700 // Phase 3, inputs and outputs
2701 model->identifyInputsAndOutputs(
2702 {input052, input152},
2703 {output052});
2704 assert(model->isValid());
2705 }
2706
is_ignored_dynamic_output_shape_53(int i)2707 inline bool is_ignored_dynamic_output_shape_53(int i) {
2708 static std::set<int> ignore = {};
2709 return ignore.find(i) != ignore.end();
2710 }
2711
CreateModel_54(Model * model)2712 void CreateModel_54(Model *model) {
2713 OperandType type1(Type::INT32, {});
2714 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
2715 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
2716 // Phase 1, operands
2717 auto input053 = model->addOperand(&type4);
2718 auto input153 = model->addOperand(&type2);
2719 auto param53 = model->addOperand(&type1);
2720 auto output053 = model->addOperand(&type2);
2721 // Phase 2, operations
2722 static int32_t param53_init[] = {0};
2723 model->setOperandValue(param53, param53_init, sizeof(int32_t) * 1);
2724 model->addOperation(ANEURALNETWORKS_SUB, {input053, input153, param53}, {output053});
2725 // Phase 3, inputs and outputs
2726 model->identifyInputsAndOutputs(
2727 {input053, input153},
2728 {output053});
2729 assert(model->isValid());
2730 }
2731
is_ignored_54(int i)2732 inline bool is_ignored_54(int i) {
2733 static std::set<int> ignore = {};
2734 return ignore.find(i) != ignore.end();
2735 }
2736
CreateModel_dynamic_output_shape_54(Model * model)2737 void CreateModel_dynamic_output_shape_54(Model *model) {
2738 OperandType type1(Type::INT32, {});
2739 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
2740 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
2741 OperandType type6(Type::TENSOR_QUANT8_ASYMM, {0}, 1.0f, 1);
2742 // Phase 1, operands
2743 auto input053 = model->addOperand(&type4);
2744 auto input153 = model->addOperand(&type2);
2745 auto param53 = model->addOperand(&type1);
2746 auto output053 = model->addOperand(&type6);
2747 // Phase 2, operations
2748 static int32_t param53_init[] = {0};
2749 model->setOperandValue(param53, param53_init, sizeof(int32_t) * 1);
2750 model->addOperation(ANEURALNETWORKS_SUB, {input053, input153, param53}, {output053});
2751 // Phase 3, inputs and outputs
2752 model->identifyInputsAndOutputs(
2753 {input053, input153},
2754 {output053});
2755 assert(model->isValid());
2756 }
2757
is_ignored_dynamic_output_shape_54(int i)2758 inline bool is_ignored_dynamic_output_shape_54(int i) {
2759 static std::set<int> ignore = {};
2760 return ignore.find(i) != ignore.end();
2761 }
2762
CreateModel_55(Model * model)2763 void CreateModel_55(Model *model) {
2764 OperandType type1(Type::INT32, {});
2765 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
2766 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
2767 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
2768 // Phase 1, operands
2769 auto input054 = model->addOperand(&type4);
2770 auto input154 = model->addOperand(&type2);
2771 auto param54 = model->addOperand(&type1);
2772 auto output054 = model->addOperand(&type3);
2773 // Phase 2, operations
2774 static int32_t param54_init[] = {0};
2775 model->setOperandValue(param54, param54_init, sizeof(int32_t) * 1);
2776 model->addOperation(ANEURALNETWORKS_SUB, {input054, input154, param54}, {output054});
2777 // Phase 3, inputs and outputs
2778 model->identifyInputsAndOutputs(
2779 {input054, input154},
2780 {output054});
2781 assert(model->isValid());
2782 }
2783
is_ignored_55(int i)2784 inline bool is_ignored_55(int i) {
2785 static std::set<int> ignore = {};
2786 return ignore.find(i) != ignore.end();
2787 }
2788
CreateModel_dynamic_output_shape_55(Model * model)2789 void CreateModel_dynamic_output_shape_55(Model *model) {
2790 OperandType type1(Type::INT32, {});
2791 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
2792 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
2793 OperandType type7(Type::TENSOR_QUANT8_ASYMM, {0}, 0.01f, 120);
2794 // Phase 1, operands
2795 auto input054 = model->addOperand(&type4);
2796 auto input154 = model->addOperand(&type2);
2797 auto param54 = model->addOperand(&type1);
2798 auto output054 = model->addOperand(&type7);
2799 // Phase 2, operations
2800 static int32_t param54_init[] = {0};
2801 model->setOperandValue(param54, param54_init, sizeof(int32_t) * 1);
2802 model->addOperation(ANEURALNETWORKS_SUB, {input054, input154, param54}, {output054});
2803 // Phase 3, inputs and outputs
2804 model->identifyInputsAndOutputs(
2805 {input054, input154},
2806 {output054});
2807 assert(model->isValid());
2808 }
2809
is_ignored_dynamic_output_shape_55(int i)2810 inline bool is_ignored_dynamic_output_shape_55(int i) {
2811 static std::set<int> ignore = {};
2812 return ignore.find(i) != ignore.end();
2813 }
2814
CreateModel_56(Model * model)2815 void CreateModel_56(Model *model) {
2816 OperandType type1(Type::INT32, {});
2817 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
2818 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
2819 // Phase 1, operands
2820 auto input055 = model->addOperand(&type4);
2821 auto input155 = model->addOperand(&type2);
2822 auto param55 = model->addOperand(&type1);
2823 auto output055 = model->addOperand(&type4);
2824 // Phase 2, operations
2825 static int32_t param55_init[] = {0};
2826 model->setOperandValue(param55, param55_init, sizeof(int32_t) * 1);
2827 model->addOperation(ANEURALNETWORKS_SUB, {input055, input155, param55}, {output055});
2828 // Phase 3, inputs and outputs
2829 model->identifyInputsAndOutputs(
2830 {input055, input155},
2831 {output055});
2832 assert(model->isValid());
2833 }
2834
is_ignored_56(int i)2835 inline bool is_ignored_56(int i) {
2836 static std::set<int> ignore = {};
2837 return ignore.find(i) != ignore.end();
2838 }
2839
CreateModel_dynamic_output_shape_56(Model * model)2840 void CreateModel_dynamic_output_shape_56(Model *model) {
2841 OperandType type1(Type::INT32, {});
2842 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
2843 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
2844 OperandType type8(Type::TENSOR_QUANT8_ASYMM, {0}, 10.0f, 120);
2845 // Phase 1, operands
2846 auto input055 = model->addOperand(&type4);
2847 auto input155 = model->addOperand(&type2);
2848 auto param55 = model->addOperand(&type1);
2849 auto output055 = model->addOperand(&type8);
2850 // Phase 2, operations
2851 static int32_t param55_init[] = {0};
2852 model->setOperandValue(param55, param55_init, sizeof(int32_t) * 1);
2853 model->addOperation(ANEURALNETWORKS_SUB, {input055, input155, param55}, {output055});
2854 // Phase 3, inputs and outputs
2855 model->identifyInputsAndOutputs(
2856 {input055, input155},
2857 {output055});
2858 assert(model->isValid());
2859 }
2860
is_ignored_dynamic_output_shape_56(int i)2861 inline bool is_ignored_dynamic_output_shape_56(int i) {
2862 static std::set<int> ignore = {};
2863 return ignore.find(i) != ignore.end();
2864 }
2865
CreateModel_57(Model * model)2866 void CreateModel_57(Model *model) {
2867 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
2868 OperandType type1(Type::INT32, {});
2869 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
2870 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
2871 // Phase 1, operands
2872 auto input056 = model->addOperand(&type4);
2873 auto input156 = model->addOperand(&type3);
2874 auto param56 = model->addOperand(&type1);
2875 auto output056 = model->addOperand(&type0);
2876 // Phase 2, operations
2877 static int32_t param56_init[] = {0};
2878 model->setOperandValue(param56, param56_init, sizeof(int32_t) * 1);
2879 model->addOperation(ANEURALNETWORKS_SUB, {input056, input156, param56}, {output056});
2880 // Phase 3, inputs and outputs
2881 model->identifyInputsAndOutputs(
2882 {input056, input156},
2883 {output056});
2884 assert(model->isValid());
2885 }
2886
is_ignored_57(int i)2887 inline bool is_ignored_57(int i) {
2888 static std::set<int> ignore = {};
2889 return ignore.find(i) != ignore.end();
2890 }
2891
CreateModel_dynamic_output_shape_57(Model * model)2892 void CreateModel_dynamic_output_shape_57(Model *model) {
2893 OperandType type1(Type::INT32, {});
2894 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
2895 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
2896 OperandType type5(Type::TENSOR_QUANT8_ASYMM, {0}, 1.0f, 0);
2897 // Phase 1, operands
2898 auto input056 = model->addOperand(&type4);
2899 auto input156 = model->addOperand(&type3);
2900 auto param56 = model->addOperand(&type1);
2901 auto output056 = model->addOperand(&type5);
2902 // Phase 2, operations
2903 static int32_t param56_init[] = {0};
2904 model->setOperandValue(param56, param56_init, sizeof(int32_t) * 1);
2905 model->addOperation(ANEURALNETWORKS_SUB, {input056, input156, param56}, {output056});
2906 // Phase 3, inputs and outputs
2907 model->identifyInputsAndOutputs(
2908 {input056, input156},
2909 {output056});
2910 assert(model->isValid());
2911 }
2912
is_ignored_dynamic_output_shape_57(int i)2913 inline bool is_ignored_dynamic_output_shape_57(int i) {
2914 static std::set<int> ignore = {};
2915 return ignore.find(i) != ignore.end();
2916 }
2917
CreateModel_58(Model * model)2918 void CreateModel_58(Model *model) {
2919 OperandType type1(Type::INT32, {});
2920 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
2921 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
2922 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
2923 // Phase 1, operands
2924 auto input057 = model->addOperand(&type4);
2925 auto input157 = model->addOperand(&type3);
2926 auto param57 = model->addOperand(&type1);
2927 auto output057 = model->addOperand(&type2);
2928 // Phase 2, operations
2929 static int32_t param57_init[] = {0};
2930 model->setOperandValue(param57, param57_init, sizeof(int32_t) * 1);
2931 model->addOperation(ANEURALNETWORKS_SUB, {input057, input157, param57}, {output057});
2932 // Phase 3, inputs and outputs
2933 model->identifyInputsAndOutputs(
2934 {input057, input157},
2935 {output057});
2936 assert(model->isValid());
2937 }
2938
is_ignored_58(int i)2939 inline bool is_ignored_58(int i) {
2940 static std::set<int> ignore = {};
2941 return ignore.find(i) != ignore.end();
2942 }
2943
CreateModel_dynamic_output_shape_58(Model * model)2944 void CreateModel_dynamic_output_shape_58(Model *model) {
2945 OperandType type1(Type::INT32, {});
2946 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
2947 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
2948 OperandType type6(Type::TENSOR_QUANT8_ASYMM, {0}, 1.0f, 1);
2949 // Phase 1, operands
2950 auto input057 = model->addOperand(&type4);
2951 auto input157 = model->addOperand(&type3);
2952 auto param57 = model->addOperand(&type1);
2953 auto output057 = model->addOperand(&type6);
2954 // Phase 2, operations
2955 static int32_t param57_init[] = {0};
2956 model->setOperandValue(param57, param57_init, sizeof(int32_t) * 1);
2957 model->addOperation(ANEURALNETWORKS_SUB, {input057, input157, param57}, {output057});
2958 // Phase 3, inputs and outputs
2959 model->identifyInputsAndOutputs(
2960 {input057, input157},
2961 {output057});
2962 assert(model->isValid());
2963 }
2964
is_ignored_dynamic_output_shape_58(int i)2965 inline bool is_ignored_dynamic_output_shape_58(int i) {
2966 static std::set<int> ignore = {};
2967 return ignore.find(i) != ignore.end();
2968 }
2969
CreateModel_59(Model * model)2970 void CreateModel_59(Model *model) {
2971 OperandType type1(Type::INT32, {});
2972 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
2973 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
2974 // Phase 1, operands
2975 auto input058 = model->addOperand(&type4);
2976 auto input158 = model->addOperand(&type3);
2977 auto param58 = model->addOperand(&type1);
2978 auto output058 = model->addOperand(&type3);
2979 // Phase 2, operations
2980 static int32_t param58_init[] = {0};
2981 model->setOperandValue(param58, param58_init, sizeof(int32_t) * 1);
2982 model->addOperation(ANEURALNETWORKS_SUB, {input058, input158, param58}, {output058});
2983 // Phase 3, inputs and outputs
2984 model->identifyInputsAndOutputs(
2985 {input058, input158},
2986 {output058});
2987 assert(model->isValid());
2988 }
2989
is_ignored_59(int i)2990 inline bool is_ignored_59(int i) {
2991 static std::set<int> ignore = {};
2992 return ignore.find(i) != ignore.end();
2993 }
2994
CreateModel_dynamic_output_shape_59(Model * model)2995 void CreateModel_dynamic_output_shape_59(Model *model) {
2996 OperandType type1(Type::INT32, {});
2997 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
2998 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
2999 OperandType type7(Type::TENSOR_QUANT8_ASYMM, {0}, 0.01f, 120);
3000 // Phase 1, operands
3001 auto input058 = model->addOperand(&type4);
3002 auto input158 = model->addOperand(&type3);
3003 auto param58 = model->addOperand(&type1);
3004 auto output058 = model->addOperand(&type7);
3005 // Phase 2, operations
3006 static int32_t param58_init[] = {0};
3007 model->setOperandValue(param58, param58_init, sizeof(int32_t) * 1);
3008 model->addOperation(ANEURALNETWORKS_SUB, {input058, input158, param58}, {output058});
3009 // Phase 3, inputs and outputs
3010 model->identifyInputsAndOutputs(
3011 {input058, input158},
3012 {output058});
3013 assert(model->isValid());
3014 }
3015
is_ignored_dynamic_output_shape_59(int i)3016 inline bool is_ignored_dynamic_output_shape_59(int i) {
3017 static std::set<int> ignore = {};
3018 return ignore.find(i) != ignore.end();
3019 }
3020
CreateModel_60(Model * model)3021 void CreateModel_60(Model *model) {
3022 OperandType type1(Type::INT32, {});
3023 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
3024 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
3025 // Phase 1, operands
3026 auto input059 = model->addOperand(&type4);
3027 auto input159 = model->addOperand(&type3);
3028 auto param59 = model->addOperand(&type1);
3029 auto output059 = model->addOperand(&type4);
3030 // Phase 2, operations
3031 static int32_t param59_init[] = {0};
3032 model->setOperandValue(param59, param59_init, sizeof(int32_t) * 1);
3033 model->addOperation(ANEURALNETWORKS_SUB, {input059, input159, param59}, {output059});
3034 // Phase 3, inputs and outputs
3035 model->identifyInputsAndOutputs(
3036 {input059, input159},
3037 {output059});
3038 assert(model->isValid());
3039 }
3040
is_ignored_60(int i)3041 inline bool is_ignored_60(int i) {
3042 static std::set<int> ignore = {};
3043 return ignore.find(i) != ignore.end();
3044 }
3045
CreateModel_dynamic_output_shape_60(Model * model)3046 void CreateModel_dynamic_output_shape_60(Model *model) {
3047 OperandType type1(Type::INT32, {});
3048 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
3049 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
3050 OperandType type8(Type::TENSOR_QUANT8_ASYMM, {0}, 10.0f, 120);
3051 // Phase 1, operands
3052 auto input059 = model->addOperand(&type4);
3053 auto input159 = model->addOperand(&type3);
3054 auto param59 = model->addOperand(&type1);
3055 auto output059 = model->addOperand(&type8);
3056 // Phase 2, operations
3057 static int32_t param59_init[] = {0};
3058 model->setOperandValue(param59, param59_init, sizeof(int32_t) * 1);
3059 model->addOperation(ANEURALNETWORKS_SUB, {input059, input159, param59}, {output059});
3060 // Phase 3, inputs and outputs
3061 model->identifyInputsAndOutputs(
3062 {input059, input159},
3063 {output059});
3064 assert(model->isValid());
3065 }
3066
is_ignored_dynamic_output_shape_60(int i)3067 inline bool is_ignored_dynamic_output_shape_60(int i) {
3068 static std::set<int> ignore = {};
3069 return ignore.find(i) != ignore.end();
3070 }
3071
CreateModel_61(Model * model)3072 void CreateModel_61(Model *model) {
3073 OperandType type0(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 0);
3074 OperandType type1(Type::INT32, {});
3075 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
3076 // Phase 1, operands
3077 auto input060 = model->addOperand(&type4);
3078 auto input160 = model->addOperand(&type4);
3079 auto param60 = model->addOperand(&type1);
3080 auto output060 = model->addOperand(&type0);
3081 // Phase 2, operations
3082 static int32_t param60_init[] = {0};
3083 model->setOperandValue(param60, param60_init, sizeof(int32_t) * 1);
3084 model->addOperation(ANEURALNETWORKS_SUB, {input060, input160, param60}, {output060});
3085 // Phase 3, inputs and outputs
3086 model->identifyInputsAndOutputs(
3087 {input060, input160},
3088 {output060});
3089 assert(model->isValid());
3090 }
3091
is_ignored_61(int i)3092 inline bool is_ignored_61(int i) {
3093 static std::set<int> ignore = {};
3094 return ignore.find(i) != ignore.end();
3095 }
3096
CreateModel_dynamic_output_shape_61(Model * model)3097 void CreateModel_dynamic_output_shape_61(Model *model) {
3098 OperandType type1(Type::INT32, {});
3099 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
3100 OperandType type5(Type::TENSOR_QUANT8_ASYMM, {0}, 1.0f, 0);
3101 // Phase 1, operands
3102 auto input060 = model->addOperand(&type4);
3103 auto input160 = model->addOperand(&type4);
3104 auto param60 = model->addOperand(&type1);
3105 auto output060 = model->addOperand(&type5);
3106 // Phase 2, operations
3107 static int32_t param60_init[] = {0};
3108 model->setOperandValue(param60, param60_init, sizeof(int32_t) * 1);
3109 model->addOperation(ANEURALNETWORKS_SUB, {input060, input160, param60}, {output060});
3110 // Phase 3, inputs and outputs
3111 model->identifyInputsAndOutputs(
3112 {input060, input160},
3113 {output060});
3114 assert(model->isValid());
3115 }
3116
is_ignored_dynamic_output_shape_61(int i)3117 inline bool is_ignored_dynamic_output_shape_61(int i) {
3118 static std::set<int> ignore = {};
3119 return ignore.find(i) != ignore.end();
3120 }
3121
CreateModel_62(Model * model)3122 void CreateModel_62(Model *model) {
3123 OperandType type1(Type::INT32, {});
3124 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {144}, 1.0f, 1);
3125 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
3126 // Phase 1, operands
3127 auto input061 = model->addOperand(&type4);
3128 auto input161 = model->addOperand(&type4);
3129 auto param61 = model->addOperand(&type1);
3130 auto output061 = model->addOperand(&type2);
3131 // Phase 2, operations
3132 static int32_t param61_init[] = {0};
3133 model->setOperandValue(param61, param61_init, sizeof(int32_t) * 1);
3134 model->addOperation(ANEURALNETWORKS_SUB, {input061, input161, param61}, {output061});
3135 // Phase 3, inputs and outputs
3136 model->identifyInputsAndOutputs(
3137 {input061, input161},
3138 {output061});
3139 assert(model->isValid());
3140 }
3141
is_ignored_62(int i)3142 inline bool is_ignored_62(int i) {
3143 static std::set<int> ignore = {};
3144 return ignore.find(i) != ignore.end();
3145 }
3146
CreateModel_dynamic_output_shape_62(Model * model)3147 void CreateModel_dynamic_output_shape_62(Model *model) {
3148 OperandType type1(Type::INT32, {});
3149 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
3150 OperandType type6(Type::TENSOR_QUANT8_ASYMM, {0}, 1.0f, 1);
3151 // Phase 1, operands
3152 auto input061 = model->addOperand(&type4);
3153 auto input161 = model->addOperand(&type4);
3154 auto param61 = model->addOperand(&type1);
3155 auto output061 = model->addOperand(&type6);
3156 // Phase 2, operations
3157 static int32_t param61_init[] = {0};
3158 model->setOperandValue(param61, param61_init, sizeof(int32_t) * 1);
3159 model->addOperation(ANEURALNETWORKS_SUB, {input061, input161, param61}, {output061});
3160 // Phase 3, inputs and outputs
3161 model->identifyInputsAndOutputs(
3162 {input061, input161},
3163 {output061});
3164 assert(model->isValid());
3165 }
3166
is_ignored_dynamic_output_shape_62(int i)3167 inline bool is_ignored_dynamic_output_shape_62(int i) {
3168 static std::set<int> ignore = {};
3169 return ignore.find(i) != ignore.end();
3170 }
3171
CreateModel_63(Model * model)3172 void CreateModel_63(Model *model) {
3173 OperandType type1(Type::INT32, {});
3174 OperandType type3(Type::TENSOR_QUANT8_ASYMM, {144}, 0.01f, 120);
3175 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
3176 // Phase 1, operands
3177 auto input062 = model->addOperand(&type4);
3178 auto input162 = model->addOperand(&type4);
3179 auto param62 = model->addOperand(&type1);
3180 auto output062 = model->addOperand(&type3);
3181 // Phase 2, operations
3182 static int32_t param62_init[] = {0};
3183 model->setOperandValue(param62, param62_init, sizeof(int32_t) * 1);
3184 model->addOperation(ANEURALNETWORKS_SUB, {input062, input162, param62}, {output062});
3185 // Phase 3, inputs and outputs
3186 model->identifyInputsAndOutputs(
3187 {input062, input162},
3188 {output062});
3189 assert(model->isValid());
3190 }
3191
is_ignored_63(int i)3192 inline bool is_ignored_63(int i) {
3193 static std::set<int> ignore = {};
3194 return ignore.find(i) != ignore.end();
3195 }
3196
CreateModel_dynamic_output_shape_63(Model * model)3197 void CreateModel_dynamic_output_shape_63(Model *model) {
3198 OperandType type1(Type::INT32, {});
3199 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
3200 OperandType type7(Type::TENSOR_QUANT8_ASYMM, {0}, 0.01f, 120);
3201 // Phase 1, operands
3202 auto input062 = model->addOperand(&type4);
3203 auto input162 = model->addOperand(&type4);
3204 auto param62 = model->addOperand(&type1);
3205 auto output062 = model->addOperand(&type7);
3206 // Phase 2, operations
3207 static int32_t param62_init[] = {0};
3208 model->setOperandValue(param62, param62_init, sizeof(int32_t) * 1);
3209 model->addOperation(ANEURALNETWORKS_SUB, {input062, input162, param62}, {output062});
3210 // Phase 3, inputs and outputs
3211 model->identifyInputsAndOutputs(
3212 {input062, input162},
3213 {output062});
3214 assert(model->isValid());
3215 }
3216
is_ignored_dynamic_output_shape_63(int i)3217 inline bool is_ignored_dynamic_output_shape_63(int i) {
3218 static std::set<int> ignore = {};
3219 return ignore.find(i) != ignore.end();
3220 }
3221
CreateModel_64(Model * model)3222 void CreateModel_64(Model *model) {
3223 OperandType type1(Type::INT32, {});
3224 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
3225 // Phase 1, operands
3226 auto input063 = model->addOperand(&type4);
3227 auto input163 = model->addOperand(&type4);
3228 auto param63 = model->addOperand(&type1);
3229 auto output063 = model->addOperand(&type4);
3230 // Phase 2, operations
3231 static int32_t param63_init[] = {0};
3232 model->setOperandValue(param63, param63_init, sizeof(int32_t) * 1);
3233 model->addOperation(ANEURALNETWORKS_SUB, {input063, input163, param63}, {output063});
3234 // Phase 3, inputs and outputs
3235 model->identifyInputsAndOutputs(
3236 {input063, input163},
3237 {output063});
3238 assert(model->isValid());
3239 }
3240
is_ignored_64(int i)3241 inline bool is_ignored_64(int i) {
3242 static std::set<int> ignore = {};
3243 return ignore.find(i) != ignore.end();
3244 }
3245
CreateModel_dynamic_output_shape_64(Model * model)3246 void CreateModel_dynamic_output_shape_64(Model *model) {
3247 OperandType type1(Type::INT32, {});
3248 OperandType type4(Type::TENSOR_QUANT8_ASYMM, {144}, 10.0f, 120);
3249 OperandType type8(Type::TENSOR_QUANT8_ASYMM, {0}, 10.0f, 120);
3250 // Phase 1, operands
3251 auto input063 = model->addOperand(&type4);
3252 auto input163 = model->addOperand(&type4);
3253 auto param63 = model->addOperand(&type1);
3254 auto output063 = model->addOperand(&type8);
3255 // Phase 2, operations
3256 static int32_t param63_init[] = {0};
3257 model->setOperandValue(param63, param63_init, sizeof(int32_t) * 1);
3258 model->addOperation(ANEURALNETWORKS_SUB, {input063, input163, param63}, {output063});
3259 // Phase 3, inputs and outputs
3260 model->identifyInputsAndOutputs(
3261 {input063, input163},
3262 {output063});
3263 assert(model->isValid());
3264 }
3265
is_ignored_dynamic_output_shape_64(int i)3266 inline bool is_ignored_dynamic_output_shape_64(int i) {
3267 static std::set<int> ignore = {};
3268 return ignore.find(i) != ignore.end();
3269 }
3270
3271