1 // Copyright 2021 Google LLC
2 //
3 // This source code is licensed under the BSD-style license found in the
4 // LICENSE file in the root directory of this source tree.
5
6 #include <xnnpack.h>
7
8 #include <array>
9 #include <algorithm>
10 #include <functional>
11 #include <iostream>
12 #include <limits>
13 #include <random>
14
15 #include <xnnpack/cache.h>
16
17 #include "models/models.h"
18
19 namespace models {
20
QC8MobileNetV2(pthreadpool_t threadpool)21 ExecutionPlan QC8MobileNetV2(pthreadpool_t threadpool) {
22 alignas(16) static std::array<int8_t, 150528 + XNN_EXTRA_BYTES / sizeof(int8_t)> v0;
23 alignas(16) static std::array<int8_t, 401408> v1;
24 alignas(16) static std::array<int8_t, 401408> v2;
25 alignas(16) static std::array<int8_t, 200704> v3;
26 alignas(16) static std::array<int8_t, 1204224> v4;
27 alignas(16) static std::array<int8_t, 301056> v5;
28 alignas(16) static std::array<int8_t, 75264> v6;
29 alignas(16) static std::array<int8_t, 451584> v7;
30 alignas(16) static std::array<int8_t, 451584> v8;
31 alignas(16) static std::array<int8_t, 75264> v9;
32 alignas(16) static std::array<int8_t, 75264> v10;
33 alignas(16) static std::array<int8_t, 451584> v11;
34 alignas(16) static std::array<int8_t, 112896> v12;
35 alignas(16) static std::array<int8_t, 25088> v13;
36 alignas(16) static std::array<int8_t, 150528> v14;
37 alignas(16) static std::array<int8_t, 150528> v15;
38 alignas(16) static std::array<int8_t, 25088> v16;
39 alignas(16) static std::array<int8_t, 25088> v17;
40 alignas(16) static std::array<int8_t, 150528> v18;
41 alignas(16) static std::array<int8_t, 150528> v19;
42 alignas(16) static std::array<int8_t, 25088> v20;
43 alignas(16) static std::array<int8_t, 25088> v21;
44 alignas(16) static std::array<int8_t, 150528> v22;
45 alignas(16) static std::array<int8_t, 37632> v23;
46 alignas(16) static std::array<int8_t, 12544> v24;
47 alignas(16) static std::array<int8_t, 75264> v25;
48 alignas(16) static std::array<int8_t, 75264> v26;
49 alignas(16) static std::array<int8_t, 12544> v27;
50 alignas(16) static std::array<int8_t, 12544> v28;
51 alignas(16) static std::array<int8_t, 75264> v29;
52 alignas(16) static std::array<int8_t, 75264> v30;
53 alignas(16) static std::array<int8_t, 12544> v31;
54 alignas(16) static std::array<int8_t, 12544> v32;
55 alignas(16) static std::array<int8_t, 75264> v33;
56 alignas(16) static std::array<int8_t, 75264> v34;
57 alignas(16) static std::array<int8_t, 12544> v35;
58 alignas(16) static std::array<int8_t, 12544> v36;
59 alignas(16) static std::array<int8_t, 75264> v37;
60 alignas(16) static std::array<int8_t, 75264> v38;
61 alignas(16) static std::array<int8_t, 18816> v39;
62 alignas(16) static std::array<int8_t, 112896> v40;
63 alignas(16) static std::array<int8_t, 112896> v41;
64 alignas(16) static std::array<int8_t, 18816> v42;
65 alignas(16) static std::array<int8_t, 18816> v43;
66 alignas(16) static std::array<int8_t, 112896> v44;
67 alignas(16) static std::array<int8_t, 112896> v45;
68 alignas(16) static std::array<int8_t, 18816> v46;
69 alignas(16) static std::array<int8_t, 18816> v47;
70 alignas(16) static std::array<int8_t, 112896> v48;
71 alignas(16) static std::array<int8_t, 28224> v49;
72 alignas(16) static std::array<int8_t, 7840> v50;
73 alignas(16) static std::array<int8_t, 47040> v51;
74 alignas(16) static std::array<int8_t, 47040> v52;
75 alignas(16) static std::array<int8_t, 7840> v53;
76 alignas(16) static std::array<int8_t, 7840> v54;
77 alignas(16) static std::array<int8_t, 47040> v55;
78 alignas(16) static std::array<int8_t, 47040> v56;
79 alignas(16) static std::array<int8_t, 7840> v57;
80 alignas(16) static std::array<int8_t, 7840> v58;
81 alignas(16) static std::array<int8_t, 47040> v59;
82 alignas(16) static std::array<int8_t, 47040> v60;
83 alignas(16) static std::array<int8_t, 15680> v61;
84 alignas(16) static std::array<int8_t, 62720> v62;
85 alignas(16) static std::array<int8_t, 1280> v63;
86 alignas(16) static std::array<int8_t, 1001> v64;
87 alignas(16) static std::array<int8_t, 864> w65;
88 alignas(16) static std::array<float, 32> s65;
89 alignas(16) static std::array<int32_t, 32> w66;
90 alignas(16) static std::array<int8_t, 288> w67;
91 alignas(16) static std::array<float, 32> s67;
92 alignas(16) static std::array<int32_t, 32> w68;
93 alignas(16) static std::array<int8_t, 512> w69;
94 alignas(16) static std::array<float, 16> s69;
95 alignas(16) static std::array<int32_t, 16> w70;
96 alignas(16) static std::array<int8_t, 1536> w71;
97 alignas(16) static std::array<float, 96> s71;
98 alignas(16) static std::array<int32_t, 96> w72;
99 alignas(16) static std::array<int8_t, 864> w73;
100 alignas(16) static std::array<float, 96> s73;
101 alignas(16) static std::array<int32_t, 96> w74;
102 alignas(16) static std::array<int8_t, 2304> w75;
103 alignas(16) static std::array<float, 24> s75;
104 alignas(16) static std::array<int32_t, 24> w76;
105 alignas(16) static std::array<int8_t, 3456> w77;
106 alignas(16) static std::array<float, 144> s77;
107 alignas(16) static std::array<int32_t, 144> w78;
108 alignas(16) static std::array<int8_t, 1296> w79;
109 alignas(16) static std::array<float, 144> s79;
110 alignas(16) static std::array<int32_t, 144> w80;
111 alignas(16) static std::array<int8_t, 3456> w81;
112 alignas(16) static std::array<float, 24> s81;
113 alignas(16) static std::array<int32_t, 24> w82;
114 alignas(16) static std::array<int8_t, 3456> w83;
115 alignas(16) static std::array<float, 144> s83;
116 alignas(16) static std::array<int32_t, 144> w84;
117 alignas(16) static std::array<int8_t, 1296> w85;
118 alignas(16) static std::array<float, 144> s85;
119 alignas(16) static std::array<int32_t, 144> w86;
120 alignas(16) static std::array<int8_t, 4608> w87;
121 alignas(16) static std::array<float, 32> s87;
122 alignas(16) static std::array<int32_t, 32> w88;
123 alignas(16) static std::array<int8_t, 6144> w89;
124 alignas(16) static std::array<float, 192> s89;
125 alignas(16) static std::array<int32_t, 192> w90;
126 alignas(16) static std::array<int8_t, 1728> w91;
127 alignas(16) static std::array<float, 192> s91;
128 alignas(16) static std::array<int32_t, 192> w92;
129 alignas(16) static std::array<int8_t, 6144> w93;
130 alignas(16) static std::array<float, 32> s93;
131 alignas(16) static std::array<int32_t, 32> w94;
132 alignas(16) static std::array<int8_t, 6144> w95;
133 alignas(16) static std::array<float, 192> s95;
134 alignas(16) static std::array<int32_t, 192> w96;
135 alignas(16) static std::array<int8_t, 1728> w97;
136 alignas(16) static std::array<float, 192> s97;
137 alignas(16) static std::array<int32_t, 192> w98;
138 alignas(16) static std::array<int8_t, 6144> w99;
139 alignas(16) static std::array<float, 32> s99;
140 alignas(16) static std::array<int32_t, 32> w100;
141 alignas(16) static std::array<int8_t, 6144> w101;
142 alignas(16) static std::array<float, 192> s101;
143 alignas(16) static std::array<int32_t, 192> w102;
144 alignas(16) static std::array<int8_t, 1728> w103;
145 alignas(16) static std::array<float, 192> s103;
146 alignas(16) static std::array<int32_t, 192> w104;
147 alignas(16) static std::array<int8_t, 12288> w105;
148 alignas(16) static std::array<float, 64> s105;
149 alignas(16) static std::array<int32_t, 64> w106;
150 alignas(16) static std::array<int8_t, 24576> w107;
151 alignas(16) static std::array<float, 384> s107;
152 alignas(16) static std::array<int32_t, 384> w108;
153 alignas(16) static std::array<int8_t, 3456> w109;
154 alignas(16) static std::array<float, 384> s109;
155 alignas(16) static std::array<int32_t, 384> w110;
156 alignas(16) static std::array<int8_t, 24576> w111;
157 alignas(16) static std::array<float, 64> s111;
158 alignas(16) static std::array<int32_t, 64> w112;
159 alignas(16) static std::array<int8_t, 24576> w113;
160 alignas(16) static std::array<float, 384> s113;
161 alignas(16) static std::array<int32_t, 384> w114;
162 alignas(16) static std::array<int8_t, 3456> w115;
163 alignas(16) static std::array<float, 384> s115;
164 alignas(16) static std::array<int32_t, 384> w116;
165 alignas(16) static std::array<int8_t, 24576> w117;
166 alignas(16) static std::array<float, 64> s117;
167 alignas(16) static std::array<int32_t, 64> w118;
168 alignas(16) static std::array<int8_t, 24576> w119;
169 alignas(16) static std::array<float, 384> s119;
170 alignas(16) static std::array<int32_t, 384> w120;
171 alignas(16) static std::array<int8_t, 3456> w121;
172 alignas(16) static std::array<float, 384> s121;
173 alignas(16) static std::array<int32_t, 384> w122;
174 alignas(16) static std::array<int8_t, 24576> w123;
175 alignas(16) static std::array<float, 64> s123;
176 alignas(16) static std::array<int32_t, 64> w124;
177 alignas(16) static std::array<int8_t, 24576> w125;
178 alignas(16) static std::array<float, 384> s125;
179 alignas(16) static std::array<int32_t, 384> w126;
180 alignas(16) static std::array<int8_t, 3456> w127;
181 alignas(16) static std::array<float, 384> s127;
182 alignas(16) static std::array<int32_t, 384> w128;
183 alignas(16) static std::array<int8_t, 36864> w129;
184 alignas(16) static std::array<float, 96> s129;
185 alignas(16) static std::array<int32_t, 96> w130;
186 alignas(16) static std::array<int8_t, 55296> w131;
187 alignas(16) static std::array<float, 576> s131;
188 alignas(16) static std::array<int32_t, 576> w132;
189 alignas(16) static std::array<int8_t, 5184> w133;
190 alignas(16) static std::array<float, 576> s133;
191 alignas(16) static std::array<int32_t, 576> w134;
192 alignas(16) static std::array<int8_t, 55296> w135;
193 alignas(16) static std::array<float, 96> s135;
194 alignas(16) static std::array<int32_t, 96> w136;
195 alignas(16) static std::array<int8_t, 55296> w137;
196 alignas(16) static std::array<float, 576> s137;
197 alignas(16) static std::array<int32_t, 576> w138;
198 alignas(16) static std::array<int8_t, 5184> w139;
199 alignas(16) static std::array<float, 576> s139;
200 alignas(16) static std::array<int32_t, 576> w140;
201 alignas(16) static std::array<int8_t, 55296> w141;
202 alignas(16) static std::array<float, 96> s141;
203 alignas(16) static std::array<int32_t, 96> w142;
204 alignas(16) static std::array<int8_t, 55296> w143;
205 alignas(16) static std::array<float, 576> s143;
206 alignas(16) static std::array<int32_t, 576> w144;
207 alignas(16) static std::array<int8_t, 5184> w145;
208 alignas(16) static std::array<float, 576> s145;
209 alignas(16) static std::array<int32_t, 576> w146;
210 alignas(16) static std::array<int8_t, 92160> w147;
211 alignas(16) static std::array<float, 160> s147;
212 alignas(16) static std::array<int32_t, 160> w148;
213 alignas(16) static std::array<int8_t, 153600> w149;
214 alignas(16) static std::array<float, 960> s149;
215 alignas(16) static std::array<int32_t, 960> w150;
216 alignas(16) static std::array<int8_t, 8640> w151;
217 alignas(16) static std::array<float, 960> s151;
218 alignas(16) static std::array<int32_t, 960> w152;
219 alignas(16) static std::array<int8_t, 153600> w153;
220 alignas(16) static std::array<float, 160> s153;
221 alignas(16) static std::array<int32_t, 160> w154;
222 alignas(16) static std::array<int8_t, 153600> w155;
223 alignas(16) static std::array<float, 960> s155;
224 alignas(16) static std::array<int32_t, 960> w156;
225 alignas(16) static std::array<int8_t, 8640> w157;
226 alignas(16) static std::array<float, 960> s157;
227 alignas(16) static std::array<int32_t, 960> w158;
228 alignas(16) static std::array<int8_t, 153600> w159;
229 alignas(16) static std::array<float, 160> s159;
230 alignas(16) static std::array<int32_t, 160> w160;
231 alignas(16) static std::array<int8_t, 153600> w161;
232 alignas(16) static std::array<float, 960> s161;
233 alignas(16) static std::array<int32_t, 960> w162;
234 alignas(16) static std::array<int8_t, 8640> w163;
235 alignas(16) static std::array<float, 960> s163;
236 alignas(16) static std::array<int32_t, 960> w164;
237 alignas(16) static std::array<int8_t, 307200> w165;
238 alignas(16) static std::array<float, 320> s165;
239 alignas(16) static std::array<int32_t, 320> w166;
240 alignas(16) static std::array<int8_t, 409600> w167;
241 alignas(16) static std::array<float, 1280> s167;
242 alignas(16) static std::array<int32_t, 1280> w168;
243 alignas(16) static std::array<int8_t, 1281280> w169;
244 alignas(16) static std::array<float, 1001> s169;
245 alignas(16) static std::array<int32_t, 1001> w170;
246
247 std::random_device random_device;
248 auto rng = std::mt19937(random_device());
249 auto i8rng = std::bind(std::uniform_int_distribution<int32_t>(-127, 127), std::ref(rng));
250 auto i32rng = std::bind(std::uniform_int_distribution<int32_t>(-10000, 10000), std::ref(rng));
251 auto srng = std::bind(std::uniform_real_distribution<float>(0.5f, 0.75f), std::ref(rng));
252 std::generate(v0.begin(), v0.end(), std::ref(i8rng));
253 std::generate(v1.begin(), v1.end(), std::ref(i8rng));
254 std::generate(v2.begin(), v2.end(), std::ref(i8rng));
255 std::generate(v3.begin(), v3.end(), std::ref(i8rng));
256 std::generate(v4.begin(), v4.end(), std::ref(i8rng));
257 std::generate(v5.begin(), v5.end(), std::ref(i8rng));
258 std::generate(v6.begin(), v6.end(), std::ref(i8rng));
259 std::generate(v7.begin(), v7.end(), std::ref(i8rng));
260 std::generate(v8.begin(), v8.end(), std::ref(i8rng));
261 std::generate(v9.begin(), v9.end(), std::ref(i8rng));
262 std::generate(v10.begin(), v10.end(), std::ref(i8rng));
263 std::generate(v11.begin(), v11.end(), std::ref(i8rng));
264 std::generate(v12.begin(), v12.end(), std::ref(i8rng));
265 std::generate(v13.begin(), v13.end(), std::ref(i8rng));
266 std::generate(v14.begin(), v14.end(), std::ref(i8rng));
267 std::generate(v15.begin(), v15.end(), std::ref(i8rng));
268 std::generate(v16.begin(), v16.end(), std::ref(i8rng));
269 std::generate(v17.begin(), v17.end(), std::ref(i8rng));
270 std::generate(v18.begin(), v18.end(), std::ref(i8rng));
271 std::generate(v19.begin(), v19.end(), std::ref(i8rng));
272 std::generate(v20.begin(), v20.end(), std::ref(i8rng));
273 std::generate(v21.begin(), v21.end(), std::ref(i8rng));
274 std::generate(v22.begin(), v22.end(), std::ref(i8rng));
275 std::generate(v23.begin(), v23.end(), std::ref(i8rng));
276 std::generate(v24.begin(), v24.end(), std::ref(i8rng));
277 std::generate(v25.begin(), v25.end(), std::ref(i8rng));
278 std::generate(v26.begin(), v26.end(), std::ref(i8rng));
279 std::generate(v27.begin(), v27.end(), std::ref(i8rng));
280 std::generate(v28.begin(), v28.end(), std::ref(i8rng));
281 std::generate(v29.begin(), v29.end(), std::ref(i8rng));
282 std::generate(v30.begin(), v30.end(), std::ref(i8rng));
283 std::generate(v31.begin(), v31.end(), std::ref(i8rng));
284 std::generate(v32.begin(), v32.end(), std::ref(i8rng));
285 std::generate(v33.begin(), v33.end(), std::ref(i8rng));
286 std::generate(v34.begin(), v34.end(), std::ref(i8rng));
287 std::generate(v35.begin(), v35.end(), std::ref(i8rng));
288 std::generate(v36.begin(), v36.end(), std::ref(i8rng));
289 std::generate(v37.begin(), v37.end(), std::ref(i8rng));
290 std::generate(v38.begin(), v38.end(), std::ref(i8rng));
291 std::generate(v39.begin(), v39.end(), std::ref(i8rng));
292 std::generate(v40.begin(), v40.end(), std::ref(i8rng));
293 std::generate(v41.begin(), v41.end(), std::ref(i8rng));
294 std::generate(v42.begin(), v42.end(), std::ref(i8rng));
295 std::generate(v43.begin(), v43.end(), std::ref(i8rng));
296 std::generate(v44.begin(), v44.end(), std::ref(i8rng));
297 std::generate(v45.begin(), v45.end(), std::ref(i8rng));
298 std::generate(v46.begin(), v46.end(), std::ref(i8rng));
299 std::generate(v47.begin(), v47.end(), std::ref(i8rng));
300 std::generate(v48.begin(), v48.end(), std::ref(i8rng));
301 std::generate(v49.begin(), v49.end(), std::ref(i8rng));
302 std::generate(v50.begin(), v50.end(), std::ref(i8rng));
303 std::generate(v51.begin(), v51.end(), std::ref(i8rng));
304 std::generate(v52.begin(), v52.end(), std::ref(i8rng));
305 std::generate(v53.begin(), v53.end(), std::ref(i8rng));
306 std::generate(v54.begin(), v54.end(), std::ref(i8rng));
307 std::generate(v55.begin(), v55.end(), std::ref(i8rng));
308 std::generate(v56.begin(), v56.end(), std::ref(i8rng));
309 std::generate(v57.begin(), v57.end(), std::ref(i8rng));
310 std::generate(v58.begin(), v58.end(), std::ref(i8rng));
311 std::generate(v59.begin(), v59.end(), std::ref(i8rng));
312 std::generate(v60.begin(), v60.end(), std::ref(i8rng));
313 std::generate(v61.begin(), v61.end(), std::ref(i8rng));
314 std::generate(v62.begin(), v62.end(), std::ref(i8rng));
315 std::generate(v63.begin(), v63.end(), std::ref(i8rng));
316 std::generate(v64.begin(), v64.end(), std::ref(i8rng));
317 std::generate(w65.begin(), w65.end(), std::ref(i8rng));
318 std::generate(s65.begin(), s65.end(), std::ref(srng));
319 std::generate(w66.begin(), w66.end(), std::ref(i32rng));
320 std::generate(w67.begin(), w67.end(), std::ref(i8rng));
321 std::generate(s67.begin(), s67.end(), std::ref(srng));
322 std::generate(w68.begin(), w68.end(), std::ref(i32rng));
323 std::generate(w69.begin(), w69.end(), std::ref(i8rng));
324 std::generate(s69.begin(), s69.end(), std::ref(srng));
325 std::generate(w70.begin(), w70.end(), std::ref(i32rng));
326 std::generate(w71.begin(), w71.end(), std::ref(i8rng));
327 std::generate(s71.begin(), s71.end(), std::ref(srng));
328 std::generate(w72.begin(), w72.end(), std::ref(i32rng));
329 std::generate(w73.begin(), w73.end(), std::ref(i8rng));
330 std::generate(s73.begin(), s73.end(), std::ref(srng));
331 std::generate(w74.begin(), w74.end(), std::ref(i32rng));
332 std::generate(w75.begin(), w75.end(), std::ref(i8rng));
333 std::generate(s75.begin(), s75.end(), std::ref(srng));
334 std::generate(w76.begin(), w76.end(), std::ref(i32rng));
335 std::generate(w77.begin(), w77.end(), std::ref(i8rng));
336 std::generate(s77.begin(), s77.end(), std::ref(srng));
337 std::generate(w78.begin(), w78.end(), std::ref(i32rng));
338 std::generate(w79.begin(), w79.end(), std::ref(i8rng));
339 std::generate(s79.begin(), s79.end(), std::ref(srng));
340 std::generate(w80.begin(), w80.end(), std::ref(i32rng));
341 std::generate(w81.begin(), w81.end(), std::ref(i8rng));
342 std::generate(s81.begin(), s81.end(), std::ref(srng));
343 std::generate(w82.begin(), w82.end(), std::ref(i32rng));
344 std::generate(w83.begin(), w83.end(), std::ref(i8rng));
345 std::generate(s83.begin(), s83.end(), std::ref(srng));
346 std::generate(w84.begin(), w84.end(), std::ref(i32rng));
347 std::generate(w85.begin(), w85.end(), std::ref(i8rng));
348 std::generate(s85.begin(), s85.end(), std::ref(srng));
349 std::generate(w86.begin(), w86.end(), std::ref(i32rng));
350 std::generate(w87.begin(), w87.end(), std::ref(i8rng));
351 std::generate(s87.begin(), s87.end(), std::ref(srng));
352 std::generate(w88.begin(), w88.end(), std::ref(i32rng));
353 std::generate(w89.begin(), w89.end(), std::ref(i8rng));
354 std::generate(s89.begin(), s89.end(), std::ref(srng));
355 std::generate(w90.begin(), w90.end(), std::ref(i32rng));
356 std::generate(w91.begin(), w91.end(), std::ref(i8rng));
357 std::generate(s91.begin(), s91.end(), std::ref(srng));
358 std::generate(w92.begin(), w92.end(), std::ref(i32rng));
359 std::generate(w93.begin(), w93.end(), std::ref(i8rng));
360 std::generate(s93.begin(), s93.end(), std::ref(srng));
361 std::generate(w94.begin(), w94.end(), std::ref(i32rng));
362 std::generate(w95.begin(), w95.end(), std::ref(i8rng));
363 std::generate(s95.begin(), s95.end(), std::ref(srng));
364 std::generate(w96.begin(), w96.end(), std::ref(i32rng));
365 std::generate(w97.begin(), w97.end(), std::ref(i8rng));
366 std::generate(s97.begin(), s97.end(), std::ref(srng));
367 std::generate(w98.begin(), w98.end(), std::ref(i32rng));
368 std::generate(w99.begin(), w99.end(), std::ref(i8rng));
369 std::generate(s99.begin(), s99.end(), std::ref(srng));
370 std::generate(w100.begin(), w100.end(), std::ref(i32rng));
371 std::generate(w101.begin(), w101.end(), std::ref(i8rng));
372 std::generate(s101.begin(), s101.end(), std::ref(srng));
373 std::generate(w102.begin(), w102.end(), std::ref(i32rng));
374 std::generate(w103.begin(), w103.end(), std::ref(i8rng));
375 std::generate(s103.begin(), s103.end(), std::ref(srng));
376 std::generate(w104.begin(), w104.end(), std::ref(i32rng));
377 std::generate(w105.begin(), w105.end(), std::ref(i8rng));
378 std::generate(s105.begin(), s105.end(), std::ref(srng));
379 std::generate(w106.begin(), w106.end(), std::ref(i32rng));
380 std::generate(w107.begin(), w107.end(), std::ref(i8rng));
381 std::generate(s107.begin(), s107.end(), std::ref(srng));
382 std::generate(w108.begin(), w108.end(), std::ref(i32rng));
383 std::generate(w109.begin(), w109.end(), std::ref(i8rng));
384 std::generate(s109.begin(), s109.end(), std::ref(srng));
385 std::generate(w110.begin(), w110.end(), std::ref(i32rng));
386 std::generate(w111.begin(), w111.end(), std::ref(i8rng));
387 std::generate(s111.begin(), s111.end(), std::ref(srng));
388 std::generate(w112.begin(), w112.end(), std::ref(i32rng));
389 std::generate(w113.begin(), w113.end(), std::ref(i8rng));
390 std::generate(s113.begin(), s113.end(), std::ref(srng));
391 std::generate(w114.begin(), w114.end(), std::ref(i32rng));
392 std::generate(w115.begin(), w115.end(), std::ref(i8rng));
393 std::generate(s115.begin(), s115.end(), std::ref(srng));
394 std::generate(w116.begin(), w116.end(), std::ref(i32rng));
395 std::generate(w117.begin(), w117.end(), std::ref(i8rng));
396 std::generate(s117.begin(), s117.end(), std::ref(srng));
397 std::generate(w118.begin(), w118.end(), std::ref(i32rng));
398 std::generate(w119.begin(), w119.end(), std::ref(i8rng));
399 std::generate(s119.begin(), s119.end(), std::ref(srng));
400 std::generate(w120.begin(), w120.end(), std::ref(i32rng));
401 std::generate(w121.begin(), w121.end(), std::ref(i8rng));
402 std::generate(s121.begin(), s121.end(), std::ref(srng));
403 std::generate(w122.begin(), w122.end(), std::ref(i32rng));
404 std::generate(w123.begin(), w123.end(), std::ref(i8rng));
405 std::generate(s123.begin(), s123.end(), std::ref(srng));
406 std::generate(w124.begin(), w124.end(), std::ref(i32rng));
407 std::generate(w125.begin(), w125.end(), std::ref(i8rng));
408 std::generate(s125.begin(), s125.end(), std::ref(srng));
409 std::generate(w126.begin(), w126.end(), std::ref(i32rng));
410 std::generate(w127.begin(), w127.end(), std::ref(i8rng));
411 std::generate(s127.begin(), s127.end(), std::ref(srng));
412 std::generate(w128.begin(), w128.end(), std::ref(i32rng));
413 std::generate(w129.begin(), w129.end(), std::ref(i8rng));
414 std::generate(s129.begin(), s129.end(), std::ref(srng));
415 std::generate(w130.begin(), w130.end(), std::ref(i32rng));
416 std::generate(w131.begin(), w131.end(), std::ref(i8rng));
417 std::generate(s131.begin(), s131.end(), std::ref(srng));
418 std::generate(w132.begin(), w132.end(), std::ref(i32rng));
419 std::generate(w133.begin(), w133.end(), std::ref(i8rng));
420 std::generate(s133.begin(), s133.end(), std::ref(srng));
421 std::generate(w134.begin(), w134.end(), std::ref(i32rng));
422 std::generate(w135.begin(), w135.end(), std::ref(i8rng));
423 std::generate(s135.begin(), s135.end(), std::ref(srng));
424 std::generate(w136.begin(), w136.end(), std::ref(i32rng));
425 std::generate(w137.begin(), w137.end(), std::ref(i8rng));
426 std::generate(s137.begin(), s137.end(), std::ref(srng));
427 std::generate(w138.begin(), w138.end(), std::ref(i32rng));
428 std::generate(w139.begin(), w139.end(), std::ref(i8rng));
429 std::generate(s139.begin(), s139.end(), std::ref(srng));
430 std::generate(w140.begin(), w140.end(), std::ref(i32rng));
431 std::generate(w141.begin(), w141.end(), std::ref(i8rng));
432 std::generate(s141.begin(), s141.end(), std::ref(srng));
433 std::generate(w142.begin(), w142.end(), std::ref(i32rng));
434 std::generate(w143.begin(), w143.end(), std::ref(i8rng));
435 std::generate(s143.begin(), s143.end(), std::ref(srng));
436 std::generate(w144.begin(), w144.end(), std::ref(i32rng));
437 std::generate(w145.begin(), w145.end(), std::ref(i8rng));
438 std::generate(s145.begin(), s145.end(), std::ref(srng));
439 std::generate(w146.begin(), w146.end(), std::ref(i32rng));
440 std::generate(w147.begin(), w147.end(), std::ref(i8rng));
441 std::generate(s147.begin(), s147.end(), std::ref(srng));
442 std::generate(w148.begin(), w148.end(), std::ref(i32rng));
443 std::generate(w149.begin(), w149.end(), std::ref(i8rng));
444 std::generate(s149.begin(), s149.end(), std::ref(srng));
445 std::generate(w150.begin(), w150.end(), std::ref(i32rng));
446 std::generate(w151.begin(), w151.end(), std::ref(i8rng));
447 std::generate(s151.begin(), s151.end(), std::ref(srng));
448 std::generate(w152.begin(), w152.end(), std::ref(i32rng));
449 std::generate(w151.begin(), w151.end(), std::ref(i8rng));
450 std::generate(s153.begin(), s153.end(), std::ref(srng));
451 std::generate(w154.begin(), w154.end(), std::ref(i32rng));
452 std::generate(w155.begin(), w155.end(), std::ref(i8rng));
453 std::generate(s155.begin(), s155.end(), std::ref(srng));
454 std::generate(w156.begin(), w156.end(), std::ref(i32rng));
455 std::generate(w157.begin(), w157.end(), std::ref(i8rng));
456 std::generate(s157.begin(), s157.end(), std::ref(srng));
457 std::generate(w158.begin(), w158.end(), std::ref(i32rng));
458 std::generate(w159.begin(), w159.end(), std::ref(i8rng));
459 std::generate(s159.begin(), s159.end(), std::ref(srng));
460 std::generate(w160.begin(), w160.end(), std::ref(i32rng));
461 std::generate(w161.begin(), w161.end(), std::ref(i8rng));
462 std::generate(s161.begin(), s161.end(), std::ref(srng));
463 std::generate(w162.begin(), w162.end(), std::ref(i32rng));
464 std::generate(w163.begin(), w163.end(), std::ref(i8rng));
465 std::generate(s163.begin(), s163.end(), std::ref(srng));
466 std::generate(w164.begin(), w164.end(), std::ref(i32rng));
467 std::generate(w165.begin(), w165.end(), std::ref(i8rng));
468 std::generate(s165.begin(), s165.end(), std::ref(srng));
469 std::generate(w166.begin(), w166.end(), std::ref(i32rng));
470 std::generate(w167.begin(), w167.end(), std::ref(i8rng));
471 std::generate(s167.begin(), s167.end(), std::ref(srng));
472 std::generate(w168.begin(), w168.end(), std::ref(i32rng));
473 std::generate(w169.begin(), w169.end(), std::ref(i8rng));
474 std::generate(s169.begin(), s169.end(), std::ref(srng));
475 std::generate(w170.begin(), w170.end(), std::ref(i32rng));
476
477 ExecutionPlan operators;
478 xnn_status status;
479 xnn_code_cache code_cache;
480 #if XNN_PLATFORM_JIT
481 xnn_init_code_cache(&code_cache);
482 #endif
483 xnn_caches caches = { 0 };
484 caches.code_cache = &code_cache;
485
486 xnn_operator_t op0 = nullptr;
487 status = xnn_create_convolution2d_nhwc_qc8(
488 0 /* top padding */, 1 /* right padding */,
489 1 /* bottom padding */, 0 /* left padding */,
490 3 /* kernel height */, 3 /* kernel width */,
491 2 /* subsampling height */, 2 /* subsampling width */,
492 1 /* dilation_height */, 1 /* dilation_width */,
493 1 /* groups */,
494 3 /* input channels per group */,
495 32 /* output_channels_per_group */,
496 3 /* input pixel stride */,
497 32 /* output pixel stride */,
498 -1 /* input zero point */, 0.5f /* input scale */,
499 s65.data(), w65.data(), w66.data(),
500 -1 /* output zero point */, 0.5f /* output scale */, -126 /* output min */, 126 /* output max */,
501 0 /* flags */,
502 &caches,
503 &op0);
504 if (status != xnn_status_success) {
505 std::cerr << "failed to create operation #0" << std::endl;
506 return ExecutionPlan();
507 }
508 operators.emplace_back(op0, xnn_delete_operator);
509
510 xnn_operator_t op1 = nullptr;
511 status = xnn_create_convolution2d_nhwc_qc8(
512 1 /* top padding */, 1 /* right padding */,
513 1 /* bottom padding */, 1 /* left padding */,
514 3 /* kernel height */, 3 /* kernel width */,
515 1 /* subsampling height */, 1 /* subsampling width */,
516 1 /* dilation_height */, 1 /* dilation_width */,
517 32 /* groups */,
518 1 /* input channels per group */,
519 1 /* output_channels_per_group */,
520 32 /* input pixel stride */,
521 32 /* output pixel stride */,
522 -1 /* input zero point */, 0.5f /* input scale */,
523 s67.data(), w67.data(), w68.data(),
524 -1 /* output zero point */, 0.5f /* output scale */, -126 /* output min */, 126 /* output max */,
525 0 /* flags */,
526 &caches,
527 &op1);
528 if (status != xnn_status_success) {
529 std::cerr << "failed to create operation #1" << std::endl;
530 return ExecutionPlan();
531 }
532 operators.emplace_back(op1, xnn_delete_operator);
533
534 xnn_operator_t op2 = nullptr;
535 status = xnn_create_convolution2d_nhwc_qc8(
536 0 /* top padding */, 0 /* right padding */,
537 0 /* bottom padding */, 0 /* left padding */,
538 1 /* kernel height */, 1 /* kernel width */,
539 1 /* subsampling height */, 1 /* subsampling width */,
540 1 /* dilation_height */, 1 /* dilation_width */,
541 1 /* groups */,
542 32 /* input channels per group */,
543 16 /* output_channels_per_group */,
544 32 /* input pixel stride */,
545 16 /* output pixel stride */,
546 -1 /* input zero point */, 0.5f /* input scale */,
547 s69.data(), w69.data(), w70.data(),
548 -1 /* output zero point */, 0.5f /* output scale */, -126 /* output min */, 126 /* output max */,
549 0 /* flags */,
550 &caches,
551 &op2);
552 if (status != xnn_status_success) {
553 std::cerr << "failed to create operation #2" << std::endl;
554 return ExecutionPlan();
555 }
556 operators.emplace_back(op2, xnn_delete_operator);
557
558 xnn_operator_t op3 = nullptr;
559 status = xnn_create_convolution2d_nhwc_qc8(
560 0 /* top padding */, 0 /* right padding */,
561 0 /* bottom padding */, 0 /* left padding */,
562 1 /* kernel height */, 1 /* kernel width */,
563 1 /* subsampling height */, 1 /* subsampling width */,
564 1 /* dilation_height */, 1 /* dilation_width */,
565 1 /* groups */,
566 16 /* input channels per group */,
567 96 /* output_channels_per_group */,
568 16 /* input pixel stride */,
569 96 /* output pixel stride */,
570 -1 /* input zero point */, 0.5f /* input scale */,
571 s71.data(), w71.data(), w72.data(),
572 -1 /* output zero point */, 0.5f /* output scale */, -126 /* output min */, 126 /* output max */,
573 0 /* flags */,
574 &caches,
575 &op3);
576 if (status != xnn_status_success) {
577 std::cerr << "failed to create operation #3" << std::endl;
578 return ExecutionPlan();
579 }
580 operators.emplace_back(op3, xnn_delete_operator);
581
582 xnn_operator_t op4 = nullptr;
583 status = xnn_create_convolution2d_nhwc_qc8(
584 0 /* top padding */, 1 /* right padding */,
585 1 /* bottom padding */, 0 /* left padding */,
586 3 /* kernel height */, 3 /* kernel width */,
587 2 /* subsampling height */, 2 /* subsampling width */,
588 1 /* dilation_height */, 1 /* dilation_width */,
589 96 /* groups */,
590 1 /* input channels per group */,
591 1 /* output_channels_per_group */,
592 96 /* input pixel stride */,
593 96 /* output pixel stride */,
594 -1 /* input zero point */, 0.5f /* input scale */,
595 s73.data(), w73.data(), w74.data(),
596 -1 /* output zero point */, 0.5f /* output scale */, -126 /* output min */, 126 /* output max */,
597 0 /* flags */,
598 &caches,
599 &op4);
600 if (status != xnn_status_success) {
601 std::cerr << "failed to create operation #4" << std::endl;
602 return ExecutionPlan();
603 }
604 operators.emplace_back(op4, xnn_delete_operator);
605
606 xnn_operator_t op5 = nullptr;
607 status = xnn_create_convolution2d_nhwc_qc8(
608 0 /* top padding */, 0 /* right padding */,
609 0 /* bottom padding */, 0 /* left padding */,
610 1 /* kernel height */, 1 /* kernel width */,
611 1 /* subsampling height */, 1 /* subsampling width */,
612 1 /* dilation_height */, 1 /* dilation_width */,
613 1 /* groups */,
614 96 /* input channels per group */,
615 24 /* output_channels_per_group */,
616 96 /* input pixel stride */,
617 24 /* output pixel stride */,
618 -1 /* input zero point */, 0.5f /* input scale */,
619 s75.data(), w75.data(), w76.data(),
620 -1 /* output zero point */, 0.5f /* output scale */, -126 /* output min */, 126 /* output max */,
621 0 /* flags */,
622 &caches,
623 &op5);
624 if (status != xnn_status_success) {
625 std::cerr << "failed to create operation #5" << std::endl;
626 return ExecutionPlan();
627 }
628 operators.emplace_back(op5, xnn_delete_operator);
629
630 xnn_operator_t op6 = nullptr;
631 status = xnn_create_convolution2d_nhwc_qc8(
632 0 /* top padding */, 0 /* right padding */,
633 0 /* bottom padding */, 0 /* left padding */,
634 1 /* kernel height */, 1 /* kernel width */,
635 1 /* subsampling height */, 1 /* subsampling width */,
636 1 /* dilation_height */, 1 /* dilation_width */,
637 1 /* groups */,
638 24 /* input channels per group */,
639 144 /* output_channels_per_group */,
640 24 /* input pixel stride */,
641 144 /* output pixel stride */,
642 -1 /* input zero point */, 0.5f /* input scale */,
643 s77.data(), w77.data(), w78.data(),
644 -1 /* output zero point */, 0.5f /* output scale */, -126 /* output min */, 126 /* output max */,
645 0 /* flags */,
646 &caches,
647 &op6);
648 if (status != xnn_status_success) {
649 std::cerr << "failed to create operation #6" << std::endl;
650 return ExecutionPlan();
651 }
652 operators.emplace_back(op6, xnn_delete_operator);
653
654 xnn_operator_t op7 = nullptr;
655 status = xnn_create_convolution2d_nhwc_qc8(
656 1 /* top padding */, 1 /* right padding */,
657 1 /* bottom padding */, 1 /* left padding */,
658 3 /* kernel height */, 3 /* kernel width */,
659 1 /* subsampling height */, 1 /* subsampling width */,
660 1 /* dilation_height */, 1 /* dilation_width */,
661 144 /* groups */,
662 1 /* input channels per group */,
663 1 /* output_channels_per_group */,
664 144 /* input pixel stride */,
665 144 /* output pixel stride */,
666 -1 /* input zero point */, 0.5f /* input scale */,
667 s79.data(), w79.data(), w80.data(),
668 -1 /* output zero point */, 0.5f /* output scale */, -126 /* output min */, 126 /* output max */,
669 0 /* flags */,
670 &caches,
671 &op7);
672 if (status != xnn_status_success) {
673 std::cerr << "failed to create operation #7" << std::endl;
674 return ExecutionPlan();
675 }
676 operators.emplace_back(op7, xnn_delete_operator);
677
678 xnn_operator_t op8 = nullptr;
679 status = xnn_create_convolution2d_nhwc_qc8(
680 0 /* top padding */, 0 /* right padding */,
681 0 /* bottom padding */, 0 /* left padding */,
682 1 /* kernel height */, 1 /* kernel width */,
683 1 /* subsampling height */, 1 /* subsampling width */,
684 1 /* dilation_height */, 1 /* dilation_width */,
685 1 /* groups */,
686 144 /* input channels per group */,
687 24 /* output_channels_per_group */,
688 144 /* input pixel stride */,
689 24 /* output pixel stride */,
690 -1 /* input zero point */, 0.5f /* input scale */,
691 s81.data(), w81.data(), w82.data(),
692 -1 /* output zero point */, 0.5f /* output scale */, -126 /* output min */, 126 /* output max */,
693 0 /* flags */,
694 &caches,
695 &op8);
696 if (status != xnn_status_success) {
697 std::cerr << "failed to create operation #8" << std::endl;
698 return ExecutionPlan();
699 }
700 operators.emplace_back(op8, xnn_delete_operator);
701
702 xnn_operator_t op9 = nullptr;
703 status = xnn_create_add_nd_qs8(
704 -1 /* input1 zero point */, 0.5f /* input1 scale */,
705 -1 /* input2 zero point */, 0.5f /* input2 scale */,
706 -1 /* output zero point */, 1.0f /* output scale */, -126 /* output min */, 126 /* output max */,
707 0 /* flags */,
708 &op9);
709 if (status != xnn_status_success) {
710 std::cerr << "failed to create operation #9" << std::endl;
711 return ExecutionPlan();
712 }
713 operators.emplace_back(op9, xnn_delete_operator);
714
715 xnn_operator_t op10 = nullptr;
716 status = xnn_create_convolution2d_nhwc_qc8(
717 0 /* top padding */, 0 /* right padding */,
718 0 /* bottom padding */, 0 /* left padding */,
719 1 /* kernel height */, 1 /* kernel width */,
720 1 /* subsampling height */, 1 /* subsampling width */,
721 1 /* dilation_height */, 1 /* dilation_width */,
722 1 /* groups */,
723 24 /* input channels per group */,
724 144 /* output_channels_per_group */,
725 24 /* input pixel stride */,
726 144 /* output pixel stride */,
727 -1 /* input zero point */, 0.5f /* input scale */,
728 s83.data(), w83.data(), w84.data(),
729 -1 /* output zero point */, 0.5f /* output scale */, -126 /* output min */, 126 /* output max */,
730 0 /* flags */,
731 &caches,
732 &op10);
733 if (status != xnn_status_success) {
734 std::cerr << "failed to create operation #10" << std::endl;
735 return ExecutionPlan();
736 }
737 operators.emplace_back(op10, xnn_delete_operator);
738
739 xnn_operator_t op11 = nullptr;
740 status = xnn_create_convolution2d_nhwc_qc8(
741 0 /* top padding */, 1 /* right padding */,
742 1 /* bottom padding */, 0 /* left padding */,
743 3 /* kernel height */, 3 /* kernel width */,
744 2 /* subsampling height */, 2 /* subsampling width */,
745 1 /* dilation_height */, 1 /* dilation_width */,
746 144 /* groups */,
747 1 /* input channels per group */,
748 1 /* output_channels_per_group */,
749 144 /* input pixel stride */,
750 144 /* output pixel stride */,
751 -1 /* input zero point */, 0.5f /* input scale */,
752 s85.data(), w85.data(), w86.data(),
753 -1 /* output zero point */, 0.5f /* output scale */, -126 /* output min */, 126 /* output max */,
754 0 /* flags */,
755 &caches,
756 &op11);
757 if (status != xnn_status_success) {
758 std::cerr << "failed to create operation #11" << std::endl;
759 return ExecutionPlan();
760 }
761 operators.emplace_back(op11, xnn_delete_operator);
762
763 xnn_operator_t op12 = nullptr;
764 status = xnn_create_convolution2d_nhwc_qc8(
765 0 /* top padding */, 0 /* right padding */,
766 0 /* bottom padding */, 0 /* left padding */,
767 1 /* kernel height */, 1 /* kernel width */,
768 1 /* subsampling height */, 1 /* subsampling width */,
769 1 /* dilation_height */, 1 /* dilation_width */,
770 1 /* groups */,
771 144 /* input channels per group */,
772 32 /* output_channels_per_group */,
773 144 /* input pixel stride */,
774 32 /* output pixel stride */,
775 -1 /* input zero point */, 0.5f /* input scale */,
776 s87.data(), w87.data(), w88.data(),
777 -1 /* output zero point */, 0.5f /* output scale */, -126 /* output min */, 126 /* output max */,
778 0 /* flags */,
779 &caches,
780 &op12);
781 if (status != xnn_status_success) {
782 std::cerr << "failed to create operation #12" << std::endl;
783 return ExecutionPlan();
784 }
785 operators.emplace_back(op12, xnn_delete_operator);
786
787 xnn_operator_t op13 = nullptr;
788 status = xnn_create_convolution2d_nhwc_qc8(
789 0 /* top padding */, 0 /* right padding */,
790 0 /* bottom padding */, 0 /* left padding */,
791 1 /* kernel height */, 1 /* kernel width */,
792 1 /* subsampling height */, 1 /* subsampling width */,
793 1 /* dilation_height */, 1 /* dilation_width */,
794 1 /* groups */,
795 32 /* input channels per group */,
796 192 /* output_channels_per_group */,
797 32 /* input pixel stride */,
798 192 /* output pixel stride */,
799 -1 /* input zero point */, 0.5f /* input scale */,
800 s89.data(), w89.data(), w90.data(),
801 -1 /* output zero point */, 0.5f /* output scale */, -126 /* output min */, 126 /* output max */,
802 0 /* flags */,
803 &caches,
804 &op13);
805 if (status != xnn_status_success) {
806 std::cerr << "failed to create operation #13" << std::endl;
807 return ExecutionPlan();
808 }
809 operators.emplace_back(op13, xnn_delete_operator);
810
811 xnn_operator_t op14 = nullptr;
812 status = xnn_create_convolution2d_nhwc_qc8(
813 1 /* top padding */, 1 /* right padding */,
814 1 /* bottom padding */, 1 /* left padding */,
815 3 /* kernel height */, 3 /* kernel width */,
816 1 /* subsampling height */, 1 /* subsampling width */,
817 1 /* dilation_height */, 1 /* dilation_width */,
818 192 /* groups */,
819 1 /* input channels per group */,
820 1 /* output_channels_per_group */,
821 192 /* input pixel stride */,
822 192 /* output pixel stride */,
823 -1 /* input zero point */, 0.5f /* input scale */,
824 s91.data(), w91.data(), w92.data(),
825 -1 /* output zero point */, 0.5f /* output scale */, -126 /* output min */, 126 /* output max */,
826 0 /* flags */,
827 &caches,
828 &op14);
829 if (status != xnn_status_success) {
830 std::cerr << "failed to create operation #14" << std::endl;
831 return ExecutionPlan();
832 }
833 operators.emplace_back(op14, xnn_delete_operator);
834
835 xnn_operator_t op15 = nullptr;
836 status = xnn_create_convolution2d_nhwc_qc8(
837 0 /* top padding */, 0 /* right padding */,
838 0 /* bottom padding */, 0 /* left padding */,
839 1 /* kernel height */, 1 /* kernel width */,
840 1 /* subsampling height */, 1 /* subsampling width */,
841 1 /* dilation_height */, 1 /* dilation_width */,
842 1 /* groups */,
843 192 /* input channels per group */,
844 32 /* output_channels_per_group */,
845 192 /* input pixel stride */,
846 32 /* output pixel stride */,
847 -1 /* input zero point */, 0.5f /* input scale */,
848 s93.data(), w93.data(), w94.data(),
849 -1 /* output zero point */, 0.5f /* output scale */, -126 /* output min */, 126 /* output max */,
850 0 /* flags */,
851 &caches,
852 &op15);
853 if (status != xnn_status_success) {
854 std::cerr << "failed to create operation #15" << std::endl;
855 return ExecutionPlan();
856 }
857 operators.emplace_back(op15, xnn_delete_operator);
858
859 xnn_operator_t op16 = nullptr;
860 status = xnn_create_add_nd_qs8(
861 -1 /* input1 zero point */, 0.5f /* input1 scale */,
862 -1 /* input2 zero point */, 0.5f /* input2 scale */,
863 -1 /* output zero point */, 1.0f /* output scale */, -126 /* output min */, 126 /* output max */,
864 0 /* flags */,
865 &op16);
866 if (status != xnn_status_success) {
867 std::cerr << "failed to create operation #16" << std::endl;
868 return ExecutionPlan();
869 }
870 operators.emplace_back(op16, xnn_delete_operator);
871
872 xnn_operator_t op17 = nullptr;
873 status = xnn_create_convolution2d_nhwc_qc8(
874 0 /* top padding */, 0 /* right padding */,
875 0 /* bottom padding */, 0 /* left padding */,
876 1 /* kernel height */, 1 /* kernel width */,
877 1 /* subsampling height */, 1 /* subsampling width */,
878 1 /* dilation_height */, 1 /* dilation_width */,
879 1 /* groups */,
880 32 /* input channels per group */,
881 192 /* output_channels_per_group */,
882 32 /* input pixel stride */,
883 192 /* output pixel stride */,
884 -1 /* input zero point */, 0.5f /* input scale */,
885 s95.data(), w95.data(), w96.data(),
886 -1 /* output zero point */, 0.5f /* output scale */, -126 /* output min */, 126 /* output max */,
887 0 /* flags */,
888 &caches,
889 &op17);
890 if (status != xnn_status_success) {
891 std::cerr << "failed to create operation #17" << std::endl;
892 return ExecutionPlan();
893 }
894 operators.emplace_back(op17, xnn_delete_operator);
895
896 xnn_operator_t op18 = nullptr;
897 status = xnn_create_convolution2d_nhwc_qc8(
898 1 /* top padding */, 1 /* right padding */,
899 1 /* bottom padding */, 1 /* left padding */,
900 3 /* kernel height */, 3 /* kernel width */,
901 1 /* subsampling height */, 1 /* subsampling width */,
902 1 /* dilation_height */, 1 /* dilation_width */,
903 192 /* groups */,
904 1 /* input channels per group */,
905 1 /* output_channels_per_group */,
906 192 /* input pixel stride */,
907 192 /* output pixel stride */,
908 -1 /* input zero point */, 0.5f /* input scale */,
909 s97.data(), w97.data(), w98.data(),
910 -1 /* output zero point */, 0.5f /* output scale */, -126 /* output min */, 126 /* output max */,
911 0 /* flags */,
912 &caches,
913 &op18);
914 if (status != xnn_status_success) {
915 std::cerr << "failed to create operation #18" << std::endl;
916 return ExecutionPlan();
917 }
918 operators.emplace_back(op18, xnn_delete_operator);
919
920 xnn_operator_t op19 = nullptr;
921 status = xnn_create_convolution2d_nhwc_qc8(
922 0 /* top padding */, 0 /* right padding */,
923 0 /* bottom padding */, 0 /* left padding */,
924 1 /* kernel height */, 1 /* kernel width */,
925 1 /* subsampling height */, 1 /* subsampling width */,
926 1 /* dilation_height */, 1 /* dilation_width */,
927 1 /* groups */,
928 192 /* input channels per group */,
929 32 /* output_channels_per_group */,
930 192 /* input pixel stride */,
931 32 /* output pixel stride */,
932 -1 /* input zero point */, 0.5f /* input scale */,
933 s99.data(), w99.data(), w100.data(),
934 -1 /* output zero point */, 0.5f /* output scale */, -126 /* output min */, 126 /* output max */,
935 0 /* flags */,
936 &caches,
937 &op19);
938 if (status != xnn_status_success) {
939 std::cerr << "failed to create operation #19" << std::endl;
940 return ExecutionPlan();
941 }
942 operators.emplace_back(op19, xnn_delete_operator);
943
944 xnn_operator_t op20 = nullptr;
945 status = xnn_create_add_nd_qs8(
946 -1 /* input1 zero point */, 0.5f /* input1 scale */,
947 -1 /* input2 zero point */, 0.5f /* input2 scale */,
948 -1 /* output zero point */, 1.0f /* output scale */, -126 /* output min */, 126 /* output max */,
949 0 /* flags */,
950 &op20);
951 if (status != xnn_status_success) {
952 std::cerr << "failed to create operation #20" << std::endl;
953 return ExecutionPlan();
954 }
955 operators.emplace_back(op20, xnn_delete_operator);
956
957 xnn_operator_t op21 = nullptr;
958 status = xnn_create_convolution2d_nhwc_qc8(
959 0 /* top padding */, 0 /* right padding */,
960 0 /* bottom padding */, 0 /* left padding */,
961 1 /* kernel height */, 1 /* kernel width */,
962 1 /* subsampling height */, 1 /* subsampling width */,
963 1 /* dilation_height */, 1 /* dilation_width */,
964 1 /* groups */,
965 32 /* input channels per group */,
966 192 /* output_channels_per_group */,
967 32 /* input pixel stride */,
968 192 /* output pixel stride */,
969 -1 /* input zero point */, 0.5f /* input scale */,
970 s101.data(), w101.data(), w102.data(),
971 -1 /* output zero point */, 0.5f /* output scale */, -126 /* output min */, 126 /* output max */,
972 0 /* flags */,
973 &caches,
974 &op21);
975 if (status != xnn_status_success) {
976 std::cerr << "failed to create operation #21" << std::endl;
977 return ExecutionPlan();
978 }
979 operators.emplace_back(op21, xnn_delete_operator);
980
981 xnn_operator_t op22 = nullptr;
982 status = xnn_create_convolution2d_nhwc_qc8(
983 0 /* top padding */, 1 /* right padding */,
984 1 /* bottom padding */, 0 /* left padding */,
985 3 /* kernel height */, 3 /* kernel width */,
986 2 /* subsampling height */, 2 /* subsampling width */,
987 1 /* dilation_height */, 1 /* dilation_width */,
988 192 /* groups */,
989 1 /* input channels per group */,
990 1 /* output_channels_per_group */,
991 192 /* input pixel stride */,
992 192 /* output pixel stride */,
993 -1 /* input zero point */, 0.5f /* input scale */,
994 s103.data(), w103.data(), w104.data(),
995 -1 /* output zero point */, 0.5f /* output scale */, -126 /* output min */, 126 /* output max */,
996 0 /* flags */,
997 &caches,
998 &op22);
999 if (status != xnn_status_success) {
1000 std::cerr << "failed to create operation #22" << std::endl;
1001 return ExecutionPlan();
1002 }
1003 operators.emplace_back(op22, xnn_delete_operator);
1004
1005 xnn_operator_t op23 = nullptr;
1006 status = xnn_create_convolution2d_nhwc_qc8(
1007 0 /* top padding */, 0 /* right padding */,
1008 0 /* bottom padding */, 0 /* left padding */,
1009 1 /* kernel height */, 1 /* kernel width */,
1010 1 /* subsampling height */, 1 /* subsampling width */,
1011 1 /* dilation_height */, 1 /* dilation_width */,
1012 1 /* groups */,
1013 192 /* input channels per group */,
1014 64 /* output_channels_per_group */,
1015 192 /* input pixel stride */,
1016 64 /* output pixel stride */,
1017 -1 /* input zero point */, 0.5f /* input scale */,
1018 s105.data(), w105.data(), w106.data(),
1019 -1 /* output zero point */, 0.5f /* output scale */, -126 /* output min */, 126 /* output max */,
1020 0 /* flags */,
1021 &caches,
1022 &op23);
1023 if (status != xnn_status_success) {
1024 std::cerr << "failed to create operation #23" << std::endl;
1025 return ExecutionPlan();
1026 }
1027 operators.emplace_back(op23, xnn_delete_operator);
1028
1029 xnn_operator_t op24 = nullptr;
1030 status = xnn_create_convolution2d_nhwc_qc8(
1031 0 /* top padding */, 0 /* right padding */,
1032 0 /* bottom padding */, 0 /* left padding */,
1033 1 /* kernel height */, 1 /* kernel width */,
1034 1 /* subsampling height */, 1 /* subsampling width */,
1035 1 /* dilation_height */, 1 /* dilation_width */,
1036 1 /* groups */,
1037 64 /* input channels per group */,
1038 384 /* output_channels_per_group */,
1039 64 /* input pixel stride */,
1040 384 /* output pixel stride */,
1041 -1 /* input zero point */, 0.5f /* input scale */,
1042 s107.data(), w107.data(), w108.data(),
1043 -1 /* output zero point */, 0.5f /* output scale */, -126 /* output min */, 126 /* output max */,
1044 0 /* flags */,
1045 &caches,
1046 &op24);
1047 if (status != xnn_status_success) {
1048 std::cerr << "failed to create operation #24" << std::endl;
1049 return ExecutionPlan();
1050 }
1051 operators.emplace_back(op24, xnn_delete_operator);
1052
1053 xnn_operator_t op25 = nullptr;
1054 status = xnn_create_convolution2d_nhwc_qc8(
1055 1 /* top padding */, 1 /* right padding */,
1056 1 /* bottom padding */, 1 /* left padding */,
1057 3 /* kernel height */, 3 /* kernel width */,
1058 1 /* subsampling height */, 1 /* subsampling width */,
1059 1 /* dilation_height */, 1 /* dilation_width */,
1060 384 /* groups */,
1061 1 /* input channels per group */,
1062 1 /* output_channels_per_group */,
1063 384 /* input pixel stride */,
1064 384 /* output pixel stride */,
1065 -1 /* input zero point */, 0.5f /* input scale */,
1066 s109.data(), w109.data(), w110.data(),
1067 -1 /* output zero point */, 0.5f /* output scale */, -126 /* output min */, 126 /* output max */,
1068 0 /* flags */,
1069 &caches,
1070 &op25);
1071 if (status != xnn_status_success) {
1072 std::cerr << "failed to create operation #25" << std::endl;
1073 return ExecutionPlan();
1074 }
1075 operators.emplace_back(op25, xnn_delete_operator);
1076
1077 xnn_operator_t op26 = nullptr;
1078 status = xnn_create_convolution2d_nhwc_qc8(
1079 0 /* top padding */, 0 /* right padding */,
1080 0 /* bottom padding */, 0 /* left padding */,
1081 1 /* kernel height */, 1 /* kernel width */,
1082 1 /* subsampling height */, 1 /* subsampling width */,
1083 1 /* dilation_height */, 1 /* dilation_width */,
1084 1 /* groups */,
1085 384 /* input channels per group */,
1086 64 /* output_channels_per_group */,
1087 384 /* input pixel stride */,
1088 64 /* output pixel stride */,
1089 -1 /* input zero point */, 0.5f /* input scale */,
1090 s111.data(), w111.data(), w112.data(),
1091 -1 /* output zero point */, 0.5f /* output scale */, -126 /* output min */, 126 /* output max */,
1092 0 /* flags */,
1093 &caches,
1094 &op26);
1095 if (status != xnn_status_success) {
1096 std::cerr << "failed to create operation #26" << std::endl;
1097 return ExecutionPlan();
1098 }
1099 operators.emplace_back(op26, xnn_delete_operator);
1100
1101 xnn_operator_t op27 = nullptr;
1102 status = xnn_create_add_nd_qs8(
1103 -1 /* input1 zero point */, 0.5f /* input1 scale */,
1104 -1 /* input2 zero point */, 0.5f /* input2 scale */,
1105 -1 /* output zero point */, 1.0f /* output scale */, -126 /* output min */, 126 /* output max */,
1106 0 /* flags */,
1107 &op27);
1108 if (status != xnn_status_success) {
1109 std::cerr << "failed to create operation #27" << std::endl;
1110 return ExecutionPlan();
1111 }
1112 operators.emplace_back(op27, xnn_delete_operator);
1113
1114 xnn_operator_t op28 = nullptr;
1115 status = xnn_create_convolution2d_nhwc_qc8(
1116 0 /* top padding */, 0 /* right padding */,
1117 0 /* bottom padding */, 0 /* left padding */,
1118 1 /* kernel height */, 1 /* kernel width */,
1119 1 /* subsampling height */, 1 /* subsampling width */,
1120 1 /* dilation_height */, 1 /* dilation_width */,
1121 1 /* groups */,
1122 64 /* input channels per group */,
1123 384 /* output_channels_per_group */,
1124 64 /* input pixel stride */,
1125 384 /* output pixel stride */,
1126 -1 /* input zero point */, 0.5f /* input scale */,
1127 s113.data(), w113.data(), w114.data(),
1128 -1 /* output zero point */, 0.5f /* output scale */, -126 /* output min */, 126 /* output max */,
1129 0 /* flags */,
1130 &caches,
1131 &op28);
1132 if (status != xnn_status_success) {
1133 std::cerr << "failed to create operation #28" << std::endl;
1134 return ExecutionPlan();
1135 }
1136 operators.emplace_back(op28, xnn_delete_operator);
1137
1138 xnn_operator_t op29 = nullptr;
1139 status = xnn_create_convolution2d_nhwc_qc8(
1140 1 /* top padding */, 1 /* right padding */,
1141 1 /* bottom padding */, 1 /* left padding */,
1142 3 /* kernel height */, 3 /* kernel width */,
1143 1 /* subsampling height */, 1 /* subsampling width */,
1144 1 /* dilation_height */, 1 /* dilation_width */,
1145 384 /* groups */,
1146 1 /* input channels per group */,
1147 1 /* output_channels_per_group */,
1148 384 /* input pixel stride */,
1149 384 /* output pixel stride */,
1150 -1 /* input zero point */, 0.5f /* input scale */,
1151 s115.data(), w115.data(), w116.data(),
1152 -1 /* output zero point */, 0.5f /* output scale */, -126 /* output min */, 126 /* output max */,
1153 0 /* flags */,
1154 &caches,
1155 &op29);
1156 if (status != xnn_status_success) {
1157 std::cerr << "failed to create operation #29" << std::endl;
1158 return ExecutionPlan();
1159 }
1160 operators.emplace_back(op29, xnn_delete_operator);
1161
1162 xnn_operator_t op30 = nullptr;
1163 status = xnn_create_convolution2d_nhwc_qc8(
1164 0 /* top padding */, 0 /* right padding */,
1165 0 /* bottom padding */, 0 /* left padding */,
1166 1 /* kernel height */, 1 /* kernel width */,
1167 1 /* subsampling height */, 1 /* subsampling width */,
1168 1 /* dilation_height */, 1 /* dilation_width */,
1169 1 /* groups */,
1170 384 /* input channels per group */,
1171 64 /* output_channels_per_group */,
1172 384 /* input pixel stride */,
1173 64 /* output pixel stride */,
1174 -1 /* input zero point */, 0.5f /* input scale */,
1175 s117.data(), w117.data(), w118.data(),
1176 -1 /* output zero point */, 0.5f /* output scale */, -126 /* output min */, 126 /* output max */,
1177 0 /* flags */,
1178 &caches,
1179 &op30);
1180 if (status != xnn_status_success) {
1181 std::cerr << "failed to create operation #30" << std::endl;
1182 return ExecutionPlan();
1183 }
1184 operators.emplace_back(op30, xnn_delete_operator);
1185
1186 xnn_operator_t op31 = nullptr;
1187 status = xnn_create_add_nd_qs8(
1188 -1 /* input1 zero point */, 0.5f /* input1 scale */,
1189 -1 /* input2 zero point */, 0.5f /* input2 scale */,
1190 -1 /* output zero point */, 1.0f /* output scale */, -126 /* output min */, 126 /* output max */,
1191 0 /* flags */,
1192 &op31);
1193 if (status != xnn_status_success) {
1194 std::cerr << "failed to create operation #31" << std::endl;
1195 return ExecutionPlan();
1196 }
1197 operators.emplace_back(op31, xnn_delete_operator);
1198
1199 xnn_operator_t op32 = nullptr;
1200 status = xnn_create_convolution2d_nhwc_qc8(
1201 0 /* top padding */, 0 /* right padding */,
1202 0 /* bottom padding */, 0 /* left padding */,
1203 1 /* kernel height */, 1 /* kernel width */,
1204 1 /* subsampling height */, 1 /* subsampling width */,
1205 1 /* dilation_height */, 1 /* dilation_width */,
1206 1 /* groups */,
1207 64 /* input channels per group */,
1208 384 /* output_channels_per_group */,
1209 64 /* input pixel stride */,
1210 384 /* output pixel stride */,
1211 -1 /* input zero point */, 0.5f /* input scale */,
1212 s119.data(), w119.data(), w120.data(),
1213 -1 /* output zero point */, 0.5f /* output scale */, -126 /* output min */, 126 /* output max */,
1214 0 /* flags */,
1215 &caches,
1216 &op32);
1217 if (status != xnn_status_success) {
1218 std::cerr << "failed to create operation #32" << std::endl;
1219 return ExecutionPlan();
1220 }
1221 operators.emplace_back(op32, xnn_delete_operator);
1222
1223 xnn_operator_t op33 = nullptr;
1224 status = xnn_create_convolution2d_nhwc_qc8(
1225 1 /* top padding */, 1 /* right padding */,
1226 1 /* bottom padding */, 1 /* left padding */,
1227 3 /* kernel height */, 3 /* kernel width */,
1228 1 /* subsampling height */, 1 /* subsampling width */,
1229 1 /* dilation_height */, 1 /* dilation_width */,
1230 384 /* groups */,
1231 1 /* input channels per group */,
1232 1 /* output_channels_per_group */,
1233 384 /* input pixel stride */,
1234 384 /* output pixel stride */,
1235 -1 /* input zero point */, 0.5f /* input scale */,
1236 s121.data(), w121.data(), w122.data(),
1237 -1 /* output zero point */, 0.5f /* output scale */, -126 /* output min */, 126 /* output max */,
1238 0 /* flags */,
1239 &caches,
1240 &op33);
1241 if (status != xnn_status_success) {
1242 std::cerr << "failed to create operation #33" << std::endl;
1243 return ExecutionPlan();
1244 }
1245 operators.emplace_back(op33, xnn_delete_operator);
1246
1247 xnn_operator_t op34 = nullptr;
1248 status = xnn_create_convolution2d_nhwc_qc8(
1249 0 /* top padding */, 0 /* right padding */,
1250 0 /* bottom padding */, 0 /* left padding */,
1251 1 /* kernel height */, 1 /* kernel width */,
1252 1 /* subsampling height */, 1 /* subsampling width */,
1253 1 /* dilation_height */, 1 /* dilation_width */,
1254 1 /* groups */,
1255 384 /* input channels per group */,
1256 64 /* output_channels_per_group */,
1257 384 /* input pixel stride */,
1258 64 /* output pixel stride */,
1259 -1 /* input zero point */, 0.5f /* input scale */,
1260 s123.data(), w123.data(), w124.data(),
1261 -1 /* output zero point */, 0.5f /* output scale */, -126 /* output min */, 126 /* output max */,
1262 0 /* flags */,
1263 &caches,
1264 &op34);
1265 if (status != xnn_status_success) {
1266 std::cerr << "failed to create operation #34" << std::endl;
1267 return ExecutionPlan();
1268 }
1269 operators.emplace_back(op34, xnn_delete_operator);
1270
1271 xnn_operator_t op35 = nullptr;
1272 status = xnn_create_add_nd_qs8(
1273 -1 /* input1 zero point */, 0.5f /* input1 scale */,
1274 -1 /* input2 zero point */, 0.5f /* input2 scale */,
1275 -1 /* output zero point */, 1.0f /* output scale */, -126 /* output min */, 126 /* output max */,
1276 0 /* flags */,
1277 &op35);
1278 if (status != xnn_status_success) {
1279 std::cerr << "failed to create operation #35" << std::endl;
1280 return ExecutionPlan();
1281 }
1282 operators.emplace_back(op35, xnn_delete_operator);
1283
1284 xnn_operator_t op36 = nullptr;
1285 status = xnn_create_convolution2d_nhwc_qc8(
1286 0 /* top padding */, 0 /* right padding */,
1287 0 /* bottom padding */, 0 /* left padding */,
1288 1 /* kernel height */, 1 /* kernel width */,
1289 1 /* subsampling height */, 1 /* subsampling width */,
1290 1 /* dilation_height */, 1 /* dilation_width */,
1291 1 /* groups */,
1292 64 /* input channels per group */,
1293 384 /* output_channels_per_group */,
1294 64 /* input pixel stride */,
1295 384 /* output pixel stride */,
1296 -1 /* input zero point */, 0.5f /* input scale */,
1297 s125.data(), w125.data(), w126.data(),
1298 -1 /* output zero point */, 0.5f /* output scale */, -126 /* output min */, 126 /* output max */,
1299 0 /* flags */,
1300 &caches,
1301 &op36);
1302 if (status != xnn_status_success) {
1303 std::cerr << "failed to create operation #36" << std::endl;
1304 return ExecutionPlan();
1305 }
1306 operators.emplace_back(op36, xnn_delete_operator);
1307
1308 xnn_operator_t op37 = nullptr;
1309 status = xnn_create_convolution2d_nhwc_qc8(
1310 1 /* top padding */, 1 /* right padding */,
1311 1 /* bottom padding */, 1 /* left padding */,
1312 3 /* kernel height */, 3 /* kernel width */,
1313 1 /* subsampling height */, 1 /* subsampling width */,
1314 1 /* dilation_height */, 1 /* dilation_width */,
1315 384 /* groups */,
1316 1 /* input channels per group */,
1317 1 /* output_channels_per_group */,
1318 384 /* input pixel stride */,
1319 384 /* output pixel stride */,
1320 -1 /* input zero point */, 0.5f /* input scale */,
1321 s127.data(), w127.data(), w128.data(),
1322 -1 /* output zero point */, 0.5f /* output scale */, -126 /* output min */, 126 /* output max */,
1323 0 /* flags */,
1324 &caches,
1325 &op37);
1326 if (status != xnn_status_success) {
1327 std::cerr << "failed to create operation #37" << std::endl;
1328 return ExecutionPlan();
1329 }
1330 operators.emplace_back(op37, xnn_delete_operator);
1331
1332 xnn_operator_t op38 = nullptr;
1333 status = xnn_create_convolution2d_nhwc_qc8(
1334 0 /* top padding */, 0 /* right padding */,
1335 0 /* bottom padding */, 0 /* left padding */,
1336 1 /* kernel height */, 1 /* kernel width */,
1337 1 /* subsampling height */, 1 /* subsampling width */,
1338 1 /* dilation_height */, 1 /* dilation_width */,
1339 1 /* groups */,
1340 384 /* input channels per group */,
1341 96 /* output_channels_per_group */,
1342 384 /* input pixel stride */,
1343 96 /* output pixel stride */,
1344 -1 /* input zero point */, 0.5f /* input scale */,
1345 s129.data(), w129.data(), w130.data(),
1346 -1 /* output zero point */, 0.5f /* output scale */, -126 /* output min */, 126 /* output max */,
1347 0 /* flags */,
1348 &caches,
1349 &op38);
1350 if (status != xnn_status_success) {
1351 std::cerr << "failed to create operation #38" << std::endl;
1352 return ExecutionPlan();
1353 }
1354 operators.emplace_back(op38, xnn_delete_operator);
1355
1356 xnn_operator_t op39 = nullptr;
1357 status = xnn_create_convolution2d_nhwc_qc8(
1358 0 /* top padding */, 0 /* right padding */,
1359 0 /* bottom padding */, 0 /* left padding */,
1360 1 /* kernel height */, 1 /* kernel width */,
1361 1 /* subsampling height */, 1 /* subsampling width */,
1362 1 /* dilation_height */, 1 /* dilation_width */,
1363 1 /* groups */,
1364 96 /* input channels per group */,
1365 576 /* output_channels_per_group */,
1366 96 /* input pixel stride */,
1367 576 /* output pixel stride */,
1368 -1 /* input zero point */, 0.5f /* input scale */,
1369 s131.data(), w131.data(), w132.data(),
1370 -1 /* output zero point */, 0.5f /* output scale */, -126 /* output min */, 126 /* output max */,
1371 0 /* flags */,
1372 &caches,
1373 &op39);
1374 if (status != xnn_status_success) {
1375 std::cerr << "failed to create operation #39" << std::endl;
1376 return ExecutionPlan();
1377 }
1378 operators.emplace_back(op39, xnn_delete_operator);
1379
1380 xnn_operator_t op40 = nullptr;
1381 status = xnn_create_convolution2d_nhwc_qc8(
1382 1 /* top padding */, 1 /* right padding */,
1383 1 /* bottom padding */, 1 /* left padding */,
1384 3 /* kernel height */, 3 /* kernel width */,
1385 1 /* subsampling height */, 1 /* subsampling width */,
1386 1 /* dilation_height */, 1 /* dilation_width */,
1387 576 /* groups */,
1388 1 /* input channels per group */,
1389 1 /* output_channels_per_group */,
1390 576 /* input pixel stride */,
1391 576 /* output pixel stride */,
1392 -1 /* input zero point */, 0.5f /* input scale */,
1393 s133.data(), w133.data(), w134.data(),
1394 -1 /* output zero point */, 0.5f /* output scale */, -126 /* output min */, 126 /* output max */,
1395 0 /* flags */,
1396 &caches,
1397 &op40);
1398 if (status != xnn_status_success) {
1399 std::cerr << "failed to create operation #40" << std::endl;
1400 return ExecutionPlan();
1401 }
1402 operators.emplace_back(op40, xnn_delete_operator);
1403
1404 xnn_operator_t op41 = nullptr;
1405 status = xnn_create_convolution2d_nhwc_qc8(
1406 0 /* top padding */, 0 /* right padding */,
1407 0 /* bottom padding */, 0 /* left padding */,
1408 1 /* kernel height */, 1 /* kernel width */,
1409 1 /* subsampling height */, 1 /* subsampling width */,
1410 1 /* dilation_height */, 1 /* dilation_width */,
1411 1 /* groups */,
1412 576 /* input channels per group */,
1413 96 /* output_channels_per_group */,
1414 576 /* input pixel stride */,
1415 96 /* output pixel stride */,
1416 -1 /* input zero point */, 0.5f /* input scale */,
1417 s135.data(), w135.data(), w136.data(),
1418 -1 /* output zero point */, 0.5f /* output scale */, -126 /* output min */, 126 /* output max */,
1419 0 /* flags */,
1420 &caches,
1421 &op41);
1422 if (status != xnn_status_success) {
1423 std::cerr << "failed to create operation #41" << std::endl;
1424 return ExecutionPlan();
1425 }
1426 operators.emplace_back(op41, xnn_delete_operator);
1427
1428 xnn_operator_t op42 = nullptr;
1429 status = xnn_create_add_nd_qs8(
1430 -1 /* input1 zero point */, 0.5f /* input1 scale */,
1431 -1 /* input2 zero point */, 0.5f /* input2 scale */,
1432 -1 /* output zero point */, 1.0f /* output scale */, -126 /* output min */, 126 /* output max */,
1433 0 /* flags */,
1434 &op42);
1435 if (status != xnn_status_success) {
1436 std::cerr << "failed to create operation #42" << std::endl;
1437 return ExecutionPlan();
1438 }
1439 operators.emplace_back(op42, xnn_delete_operator);
1440
1441 xnn_operator_t op43 = nullptr;
1442 status = xnn_create_convolution2d_nhwc_qc8(
1443 0 /* top padding */, 0 /* right padding */,
1444 0 /* bottom padding */, 0 /* left padding */,
1445 1 /* kernel height */, 1 /* kernel width */,
1446 1 /* subsampling height */, 1 /* subsampling width */,
1447 1 /* dilation_height */, 1 /* dilation_width */,
1448 1 /* groups */,
1449 96 /* input channels per group */,
1450 576 /* output_channels_per_group */,
1451 96 /* input pixel stride */,
1452 576 /* output pixel stride */,
1453 -1 /* input zero point */, 0.5f /* input scale */,
1454 s137.data(), w137.data(), w138.data(),
1455 -1 /* output zero point */, 0.5f /* output scale */, -126 /* output min */, 126 /* output max */,
1456 0 /* flags */,
1457 &caches,
1458 &op43);
1459 if (status != xnn_status_success) {
1460 std::cerr << "failed to create operation #43" << std::endl;
1461 return ExecutionPlan();
1462 }
1463 operators.emplace_back(op43, xnn_delete_operator);
1464
1465 xnn_operator_t op44 = nullptr;
1466 status = xnn_create_convolution2d_nhwc_qc8(
1467 1 /* top padding */, 1 /* right padding */,
1468 1 /* bottom padding */, 1 /* left padding */,
1469 3 /* kernel height */, 3 /* kernel width */,
1470 1 /* subsampling height */, 1 /* subsampling width */,
1471 1 /* dilation_height */, 1 /* dilation_width */,
1472 576 /* groups */,
1473 1 /* input channels per group */,
1474 1 /* output_channels_per_group */,
1475 576 /* input pixel stride */,
1476 576 /* output pixel stride */,
1477 -1 /* input zero point */, 0.5f /* input scale */,
1478 s139.data(), w139.data(), w140.data(),
1479 -1 /* output zero point */, 0.5f /* output scale */, -126 /* output min */, 126 /* output max */,
1480 0 /* flags */,
1481 &caches,
1482 &op44);
1483 if (status != xnn_status_success) {
1484 std::cerr << "failed to create operation #44" << std::endl;
1485 return ExecutionPlan();
1486 }
1487 operators.emplace_back(op44, xnn_delete_operator);
1488
1489 xnn_operator_t op45 = nullptr;
1490 status = xnn_create_convolution2d_nhwc_qc8(
1491 0 /* top padding */, 0 /* right padding */,
1492 0 /* bottom padding */, 0 /* left padding */,
1493 1 /* kernel height */, 1 /* kernel width */,
1494 1 /* subsampling height */, 1 /* subsampling width */,
1495 1 /* dilation_height */, 1 /* dilation_width */,
1496 1 /* groups */,
1497 576 /* input channels per group */,
1498 96 /* output_channels_per_group */,
1499 576 /* input pixel stride */,
1500 96 /* output pixel stride */,
1501 -1 /* input zero point */, 0.5f /* input scale */,
1502 s141.data(), w141.data(), w142.data(),
1503 -1 /* output zero point */, 0.5f /* output scale */, -126 /* output min */, 126 /* output max */,
1504 0 /* flags */,
1505 &caches,
1506 &op45);
1507 if (status != xnn_status_success) {
1508 std::cerr << "failed to create operation #45" << std::endl;
1509 return ExecutionPlan();
1510 }
1511 operators.emplace_back(op45, xnn_delete_operator);
1512
1513 xnn_operator_t op46 = nullptr;
1514 status = xnn_create_add_nd_qs8(
1515 -1 /* input1 zero point */, 0.5f /* input1 scale */,
1516 -1 /* input2 zero point */, 0.5f /* input2 scale */,
1517 -1 /* output zero point */, 1.0f /* output scale */, -126 /* output min */, 126 /* output max */,
1518 0 /* flags */,
1519 &op46);
1520 if (status != xnn_status_success) {
1521 std::cerr << "failed to create operation #46" << std::endl;
1522 return ExecutionPlan();
1523 }
1524 operators.emplace_back(op46, xnn_delete_operator);
1525
1526 xnn_operator_t op47 = nullptr;
1527 status = xnn_create_convolution2d_nhwc_qc8(
1528 0 /* top padding */, 0 /* right padding */,
1529 0 /* bottom padding */, 0 /* left padding */,
1530 1 /* kernel height */, 1 /* kernel width */,
1531 1 /* subsampling height */, 1 /* subsampling width */,
1532 1 /* dilation_height */, 1 /* dilation_width */,
1533 1 /* groups */,
1534 96 /* input channels per group */,
1535 576 /* output_channels_per_group */,
1536 96 /* input pixel stride */,
1537 576 /* output pixel stride */,
1538 -1 /* input zero point */, 0.5f /* input scale */,
1539 s143.data(), w143.data(), w144.data(),
1540 -1 /* output zero point */, 0.5f /* output scale */, -126 /* output min */, 126 /* output max */,
1541 0 /* flags */,
1542 &caches,
1543 &op47);
1544 if (status != xnn_status_success) {
1545 std::cerr << "failed to create operation #47" << std::endl;
1546 return ExecutionPlan();
1547 }
1548 operators.emplace_back(op47, xnn_delete_operator);
1549
1550 xnn_operator_t op48 = nullptr;
1551 status = xnn_create_convolution2d_nhwc_qc8(
1552 0 /* top padding */, 1 /* right padding */,
1553 1 /* bottom padding */, 0 /* left padding */,
1554 3 /* kernel height */, 3 /* kernel width */,
1555 2 /* subsampling height */, 2 /* subsampling width */,
1556 1 /* dilation_height */, 1 /* dilation_width */,
1557 576 /* groups */,
1558 1 /* input channels per group */,
1559 1 /* output_channels_per_group */,
1560 576 /* input pixel stride */,
1561 576 /* output pixel stride */,
1562 -1 /* input zero point */, 0.5f /* input scale */,
1563 s145.data(), w145.data(), w146.data(),
1564 -1 /* output zero point */, 0.5f /* output scale */, -126 /* output min */, 126 /* output max */,
1565 0 /* flags */,
1566 &caches,
1567 &op48);
1568 if (status != xnn_status_success) {
1569 std::cerr << "failed to create operation #48" << std::endl;
1570 return ExecutionPlan();
1571 }
1572 operators.emplace_back(op48, xnn_delete_operator);
1573
1574 xnn_operator_t op49 = nullptr;
1575 status = xnn_create_convolution2d_nhwc_qc8(
1576 0 /* top padding */, 0 /* right padding */,
1577 0 /* bottom padding */, 0 /* left padding */,
1578 1 /* kernel height */, 1 /* kernel width */,
1579 1 /* subsampling height */, 1 /* subsampling width */,
1580 1 /* dilation_height */, 1 /* dilation_width */,
1581 1 /* groups */,
1582 576 /* input channels per group */,
1583 160 /* output_channels_per_group */,
1584 576 /* input pixel stride */,
1585 160 /* output pixel stride */,
1586 -1 /* input zero point */, 0.5f /* input scale */,
1587 s147.data(), w147.data(), w148.data(),
1588 -1 /* output zero point */, 0.5f /* output scale */, -126 /* output min */, 126 /* output max */,
1589 0 /* flags */,
1590 &caches,
1591 &op49);
1592 if (status != xnn_status_success) {
1593 std::cerr << "failed to create operation #49" << std::endl;
1594 return ExecutionPlan();
1595 }
1596 operators.emplace_back(op49, xnn_delete_operator);
1597
1598 xnn_operator_t op50 = nullptr;
1599 status = xnn_create_convolution2d_nhwc_qc8(
1600 0 /* top padding */, 0 /* right padding */,
1601 0 /* bottom padding */, 0 /* left padding */,
1602 1 /* kernel height */, 1 /* kernel width */,
1603 1 /* subsampling height */, 1 /* subsampling width */,
1604 1 /* dilation_height */, 1 /* dilation_width */,
1605 1 /* groups */,
1606 160 /* input channels per group */,
1607 960 /* output_channels_per_group */,
1608 160 /* input pixel stride */,
1609 960 /* output pixel stride */,
1610 -1 /* input zero point */, 0.5f /* input scale */,
1611 s149.data(), w149.data(), w150.data(),
1612 -1 /* output zero point */, 0.5f /* output scale */, -126 /* output min */, 126 /* output max */,
1613 0 /* flags */,
1614 &caches,
1615 &op50);
1616 if (status != xnn_status_success) {
1617 std::cerr << "failed to create operation #50" << std::endl;
1618 return ExecutionPlan();
1619 }
1620 operators.emplace_back(op50, xnn_delete_operator);
1621
1622 xnn_operator_t op51 = nullptr;
1623 status = xnn_create_convolution2d_nhwc_qc8(
1624 1 /* top padding */, 1 /* right padding */,
1625 1 /* bottom padding */, 1 /* left padding */,
1626 3 /* kernel height */, 3 /* kernel width */,
1627 1 /* subsampling height */, 1 /* subsampling width */,
1628 1 /* dilation_height */, 1 /* dilation_width */,
1629 960 /* groups */,
1630 1 /* input channels per group */,
1631 1 /* output_channels_per_group */,
1632 960 /* input pixel stride */,
1633 960 /* output pixel stride */,
1634 -1 /* input zero point */, 0.5f /* input scale */,
1635 s151.data(), w151.data(), w152.data(),
1636 -1 /* output zero point */, 0.5f /* output scale */, -126 /* output min */, 126 /* output max */,
1637 0 /* flags */,
1638 &caches,
1639 &op51);
1640 if (status != xnn_status_success) {
1641 std::cerr << "failed to create operation #51" << std::endl;
1642 return ExecutionPlan();
1643 }
1644 operators.emplace_back(op51, xnn_delete_operator);
1645
1646 xnn_operator_t op52 = nullptr;
1647 status = xnn_create_convolution2d_nhwc_qc8(
1648 0 /* top padding */, 0 /* right padding */,
1649 0 /* bottom padding */, 0 /* left padding */,
1650 1 /* kernel height */, 1 /* kernel width */,
1651 1 /* subsampling height */, 1 /* subsampling width */,
1652 1 /* dilation_height */, 1 /* dilation_width */,
1653 1 /* groups */,
1654 960 /* input channels per group */,
1655 160 /* output_channels_per_group */,
1656 960 /* input pixel stride */,
1657 160 /* output pixel stride */,
1658 -1 /* input zero point */, 0.5f /* input scale */,
1659 s153.data(), w153.data(), w154.data(),
1660 -1 /* output zero point */, 0.5f /* output scale */, -126 /* output min */, 126 /* output max */,
1661 0 /* flags */,
1662 &caches,
1663 &op52);
1664 if (status != xnn_status_success) {
1665 std::cerr << "failed to create operation #52" << std::endl;
1666 return ExecutionPlan();
1667 }
1668 operators.emplace_back(op52, xnn_delete_operator);
1669
1670 xnn_operator_t op53 = nullptr;
1671 status = xnn_create_add_nd_qs8(
1672 -1 /* input1 zero point */, 0.5f /* input1 scale */,
1673 -1 /* input2 zero point */, 0.5f /* input2 scale */,
1674 -1 /* output zero point */, 1.0f /* output scale */, -126 /* output min */, 126 /* output max */,
1675 0 /* flags */,
1676 &op53);
1677 if (status != xnn_status_success) {
1678 std::cerr << "failed to create operation #53" << std::endl;
1679 return ExecutionPlan();
1680 }
1681 operators.emplace_back(op53, xnn_delete_operator);
1682
1683 xnn_operator_t op54 = nullptr;
1684 status = xnn_create_convolution2d_nhwc_qc8(
1685 0 /* top padding */, 0 /* right padding */,
1686 0 /* bottom padding */, 0 /* left padding */,
1687 1 /* kernel height */, 1 /* kernel width */,
1688 1 /* subsampling height */, 1 /* subsampling width */,
1689 1 /* dilation_height */, 1 /* dilation_width */,
1690 1 /* groups */,
1691 160 /* input channels per group */,
1692 960 /* output_channels_per_group */,
1693 160 /* input pixel stride */,
1694 960 /* output pixel stride */,
1695 -1 /* input zero point */, 0.5f /* input scale */,
1696 s155.data(), w155.data(), w156.data(),
1697 -1 /* output zero point */, 0.5f /* output scale */, -126 /* output min */, 126 /* output max */,
1698 0 /* flags */,
1699 &caches,
1700 &op54);
1701 if (status != xnn_status_success) {
1702 std::cerr << "failed to create operation #54" << std::endl;
1703 return ExecutionPlan();
1704 }
1705 operators.emplace_back(op54, xnn_delete_operator);
1706
1707 xnn_operator_t op55 = nullptr;
1708 status = xnn_create_convolution2d_nhwc_qc8(
1709 1 /* top padding */, 1 /* right padding */,
1710 1 /* bottom padding */, 1 /* left padding */,
1711 3 /* kernel height */, 3 /* kernel width */,
1712 1 /* subsampling height */, 1 /* subsampling width */,
1713 1 /* dilation_height */, 1 /* dilation_width */,
1714 960 /* groups */,
1715 1 /* input channels per group */,
1716 1 /* output_channels_per_group */,
1717 960 /* input pixel stride */,
1718 960 /* output pixel stride */,
1719 -1 /* input zero point */, 0.5f /* input scale */,
1720 s157.data(), w157.data(), w158.data(),
1721 -1 /* output zero point */, 0.5f /* output scale */, -126 /* output min */, 126 /* output max */,
1722 0 /* flags */,
1723 &caches,
1724 &op55);
1725 if (status != xnn_status_success) {
1726 std::cerr << "failed to create operation #55" << std::endl;
1727 return ExecutionPlan();
1728 }
1729 operators.emplace_back(op55, xnn_delete_operator);
1730
1731 xnn_operator_t op56 = nullptr;
1732 status = xnn_create_convolution2d_nhwc_qc8(
1733 0 /* top padding */, 0 /* right padding */,
1734 0 /* bottom padding */, 0 /* left padding */,
1735 1 /* kernel height */, 1 /* kernel width */,
1736 1 /* subsampling height */, 1 /* subsampling width */,
1737 1 /* dilation_height */, 1 /* dilation_width */,
1738 1 /* groups */,
1739 960 /* input channels per group */,
1740 160 /* output_channels_per_group */,
1741 960 /* input pixel stride */,
1742 160 /* output pixel stride */,
1743 -1 /* input zero point */, 0.5f /* input scale */,
1744 s159.data(), w159.data(), w160.data(),
1745 -1 /* output zero point */, 0.5f /* output scale */, -126 /* output min */, 126 /* output max */,
1746 0 /* flags */,
1747 &caches,
1748 &op56);
1749 if (status != xnn_status_success) {
1750 std::cerr << "failed to create operation #56" << std::endl;
1751 return ExecutionPlan();
1752 }
1753 operators.emplace_back(op56, xnn_delete_operator);
1754
1755 xnn_operator_t op57 = nullptr;
1756 status = xnn_create_add_nd_qs8(
1757 -1 /* input1 zero point */, 0.5f /* input1 scale */,
1758 -1 /* input2 zero point */, 0.5f /* input2 scale */,
1759 -1 /* output zero point */, 1.0f /* output scale */, -126 /* output min */, 126 /* output max */,
1760 0 /* flags */,
1761 &op57);
1762 if (status != xnn_status_success) {
1763 std::cerr << "failed to create operation #57" << std::endl;
1764 return ExecutionPlan();
1765 }
1766 operators.emplace_back(op57, xnn_delete_operator);
1767
1768 xnn_operator_t op58 = nullptr;
1769 status = xnn_create_convolution2d_nhwc_qc8(
1770 0 /* top padding */, 0 /* right padding */,
1771 0 /* bottom padding */, 0 /* left padding */,
1772 1 /* kernel height */, 1 /* kernel width */,
1773 1 /* subsampling height */, 1 /* subsampling width */,
1774 1 /* dilation_height */, 1 /* dilation_width */,
1775 1 /* groups */,
1776 160 /* input channels per group */,
1777 960 /* output_channels_per_group */,
1778 160 /* input pixel stride */,
1779 960 /* output pixel stride */,
1780 -1 /* input zero point */, 0.5f /* input scale */,
1781 s161.data(), w161.data(), w162.data(),
1782 -1 /* output zero point */, 0.5f /* output scale */, -126 /* output min */, 126 /* output max */,
1783 0 /* flags */,
1784 &caches,
1785 &op58);
1786 if (status != xnn_status_success) {
1787 std::cerr << "failed to create operation #58" << std::endl;
1788 return ExecutionPlan();
1789 }
1790 operators.emplace_back(op58, xnn_delete_operator);
1791
1792 xnn_operator_t op59 = nullptr;
1793 status = xnn_create_convolution2d_nhwc_qc8(
1794 1 /* top padding */, 1 /* right padding */,
1795 1 /* bottom padding */, 1 /* left padding */,
1796 3 /* kernel height */, 3 /* kernel width */,
1797 1 /* subsampling height */, 1 /* subsampling width */,
1798 1 /* dilation_height */, 1 /* dilation_width */,
1799 960 /* groups */,
1800 1 /* input channels per group */,
1801 1 /* output_channels_per_group */,
1802 960 /* input pixel stride */,
1803 960 /* output pixel stride */,
1804 -1 /* input zero point */, 0.5f /* input scale */,
1805 s163.data(), w163.data(), w164.data(),
1806 -1 /* output zero point */, 0.5f /* output scale */, -126 /* output min */, 126 /* output max */,
1807 0 /* flags */,
1808 &caches,
1809 &op59);
1810 if (status != xnn_status_success) {
1811 std::cerr << "failed to create operation #59" << std::endl;
1812 return ExecutionPlan();
1813 }
1814 operators.emplace_back(op59, xnn_delete_operator);
1815
1816 xnn_operator_t op60 = nullptr;
1817 status = xnn_create_convolution2d_nhwc_qc8(
1818 0 /* top padding */, 0 /* right padding */,
1819 0 /* bottom padding */, 0 /* left padding */,
1820 1 /* kernel height */, 1 /* kernel width */,
1821 1 /* subsampling height */, 1 /* subsampling width */,
1822 1 /* dilation_height */, 1 /* dilation_width */,
1823 1 /* groups */,
1824 960 /* input channels per group */,
1825 320 /* output_channels_per_group */,
1826 960 /* input pixel stride */,
1827 320 /* output pixel stride */,
1828 -1 /* input zero point */, 0.5f /* input scale */,
1829 s165.data(), w165.data(), w166.data(),
1830 -1 /* output zero point */, 0.5f /* output scale */, -126 /* output min */, 126 /* output max */,
1831 0 /* flags */,
1832 &caches,
1833 &op60);
1834 if (status != xnn_status_success) {
1835 std::cerr << "failed to create operation #60" << std::endl;
1836 return ExecutionPlan();
1837 }
1838 operators.emplace_back(op60, xnn_delete_operator);
1839
1840 xnn_operator_t op61 = nullptr;
1841 status = xnn_create_convolution2d_nhwc_qc8(
1842 0 /* top padding */, 0 /* right padding */,
1843 0 /* bottom padding */, 0 /* left padding */,
1844 1 /* kernel height */, 1 /* kernel width */,
1845 1 /* subsampling height */, 1 /* subsampling width */,
1846 1 /* dilation_height */, 1 /* dilation_width */,
1847 1 /* groups */,
1848 320 /* input channels per group */,
1849 1280 /* output_channels_per_group */,
1850 320 /* input pixel stride */,
1851 1280 /* output pixel stride */,
1852 -1 /* input zero point */, 0.5f /* input scale */,
1853 s167.data(), w167.data(), w168.data(),
1854 -1 /* output zero point */, 0.5f /* output scale */, -126 /* output min */, 126 /* output max */,
1855 0 /* flags */,
1856 &caches,
1857 &op61);
1858 if (status != xnn_status_success) {
1859 std::cerr << "failed to create operation #61" << std::endl;
1860 return ExecutionPlan();
1861 }
1862 operators.emplace_back(op61, xnn_delete_operator);
1863
1864 xnn_operator_t op62 = nullptr;
1865 status = xnn_create_global_average_pooling_nwc_qs8(
1866 1280 /* channels */, 1280 /* input stride */, 1280 /* output stride */,
1867 -1 /* input zero point */, 0.5f /* input scale */,
1868 -1 /* output zero point */, 0.5f /* output scale */, -126 /* output min */, 126 /* output max */,
1869 0 /* flags */,
1870 &op62);
1871 if (status != xnn_status_success) {
1872 std::cerr << "failed to create operation #62" << std::endl;
1873 return ExecutionPlan();
1874 }
1875 operators.emplace_back(op62, xnn_delete_operator);
1876
1877 xnn_operator_t op63 = nullptr;
1878 status = xnn_create_convolution2d_nhwc_qc8(
1879 0 /* top padding */, 0 /* right padding */,
1880 0 /* bottom padding */, 0 /* left padding */,
1881 1 /* kernel height */, 1 /* kernel width */,
1882 1 /* subsampling height */, 1 /* subsampling width */,
1883 1 /* dilation_height */, 1 /* dilation_width */,
1884 1 /* groups */,
1885 1280 /* input channels per group */,
1886 1001 /* output_channels_per_group */,
1887 1280 /* input pixel stride */,
1888 1001 /* output pixel stride */,
1889 -1 /* input zero point */, 0.5f /* input scale */,
1890 s169.data(), w169.data(), w170.data(),
1891 -1 /* output zero point */, 0.5f /* output scale */, -126 /* output min */, 126 /* output max */,
1892 0 /* flags */,
1893 &caches,
1894 &op63);
1895 if (status != xnn_status_success) {
1896 std::cerr << "failed to create operation #63" << std::endl;
1897 return ExecutionPlan();
1898 }
1899 operators.emplace_back(op63, xnn_delete_operator);
1900
1901 #if XNN_PLATFORM_JIT
1902 xnn_finalize_code_memory(&code_cache.cache.code);
1903 #endif
1904
1905 status = xnn_setup_convolution2d_nhwc_qc8(
1906 op0,
1907 1 /* batch size */, 224 /* input height */, 224 /* input width */,
1908 v0.data() /* input */, v1.data() /* output */,
1909 threadpool /* threadpool */);
1910 if (status != xnn_status_success) {
1911 std::cerr << "failed to setup operation #0" << std::endl;
1912 return ExecutionPlan();
1913 }
1914
1915 status = xnn_setup_convolution2d_nhwc_qc8(
1916 op1,
1917 1 /* batch size */, 112 /* input height */, 112 /* input width */,
1918 v1.data() /* input */, v2.data() /* output */,
1919 threadpool /* threadpool */);
1920 if (status != xnn_status_success) {
1921 std::cerr << "failed to setup operation #1" << std::endl;
1922 return ExecutionPlan();
1923 }
1924
1925 status = xnn_setup_convolution2d_nhwc_qc8(
1926 op2,
1927 1 /* batch size */, 112 /* input height */, 112 /* input width */,
1928 v2.data() /* input */, v3.data() /* output */,
1929 threadpool /* threadpool */);
1930 if (status != xnn_status_success) {
1931 std::cerr << "failed to setup operation #2" << std::endl;
1932 return ExecutionPlan();
1933 }
1934
1935 status = xnn_setup_convolution2d_nhwc_qc8(
1936 op3,
1937 1 /* batch size */, 112 /* input height */, 112 /* input width */,
1938 v3.data() /* input */, v4.data() /* output */,
1939 threadpool /* threadpool */);
1940 if (status != xnn_status_success) {
1941 std::cerr << "failed to setup operation #3" << std::endl;
1942 return ExecutionPlan();
1943 }
1944
1945 status = xnn_setup_convolution2d_nhwc_qc8(
1946 op4,
1947 1 /* batch size */, 112 /* input height */, 112 /* input width */,
1948 v4.data() /* input */, v5.data() /* output */,
1949 threadpool /* threadpool */);
1950 if (status != xnn_status_success) {
1951 std::cerr << "failed to setup operation #4" << std::endl;
1952 return ExecutionPlan();
1953 }
1954
1955 status = xnn_setup_convolution2d_nhwc_qc8(
1956 op5,
1957 1 /* batch size */, 56 /* input height */, 56 /* input width */,
1958 v5.data() /* input */, v6.data() /* output */,
1959 threadpool /* threadpool */);
1960 if (status != xnn_status_success) {
1961 std::cerr << "failed to setup operation #5" << std::endl;
1962 return ExecutionPlan();
1963 }
1964
1965 status = xnn_setup_convolution2d_nhwc_qc8(
1966 op6,
1967 1 /* batch size */, 56 /* input height */, 56 /* input width */,
1968 v6.data() /* input */, v7.data() /* output */,
1969 threadpool /* threadpool */);
1970 if (status != xnn_status_success) {
1971 std::cerr << "failed to setup operation #6" << std::endl;
1972 return ExecutionPlan();
1973 }
1974
1975 status = xnn_setup_convolution2d_nhwc_qc8(
1976 op7,
1977 1 /* batch size */, 56 /* input height */, 56 /* input width */,
1978 v7.data() /* input */, v8.data() /* output */,
1979 threadpool /* threadpool */);
1980 if (status != xnn_status_success) {
1981 std::cerr << "failed to setup operation #7" << std::endl;
1982 return ExecutionPlan();
1983 }
1984
1985 status = xnn_setup_convolution2d_nhwc_qc8(
1986 op8,
1987 1 /* batch size */, 56 /* input height */, 56 /* input width */,
1988 v8.data() /* input */, v9.data() /* output */,
1989 threadpool /* threadpool */);
1990 if (status != xnn_status_success) {
1991 std::cerr << "failed to setup operation #8" << std::endl;
1992 return ExecutionPlan();
1993 }
1994
1995 {
1996 const size_t a_shape[] = { 1, 56, 56, 24 };
1997 const size_t b_shape[] = { 1, 56, 56, 24 };
1998 status = xnn_setup_add_nd_qs8(
1999 op9,
2000 4, a_shape, 4, b_shape,
2001 v9.data() /* a */, v6.data() /* b */, v10.data() /* output */,
2002 threadpool /* threadpool */);
2003 }
2004 if (status != xnn_status_success) {
2005 std::cerr << "failed to setup operation #9" << std::endl;
2006 return ExecutionPlan();
2007 }
2008
2009 status = xnn_setup_convolution2d_nhwc_qc8(
2010 op10,
2011 1 /* batch size */, 56 /* input height */, 56 /* input width */,
2012 v10.data() /* input */, v11.data() /* output */,
2013 threadpool /* threadpool */);
2014 if (status != xnn_status_success) {
2015 std::cerr << "failed to setup operation #10" << std::endl;
2016 return ExecutionPlan();
2017 }
2018
2019 status = xnn_setup_convolution2d_nhwc_qc8(
2020 op11,
2021 1 /* batch size */, 56 /* input height */, 56 /* input width */,
2022 v11.data() /* input */, v12.data() /* output */,
2023 threadpool /* threadpool */);
2024 if (status != xnn_status_success) {
2025 std::cerr << "failed to setup operation #11" << std::endl;
2026 return ExecutionPlan();
2027 }
2028
2029 status = xnn_setup_convolution2d_nhwc_qc8(
2030 op12,
2031 1 /* batch size */, 28 /* input height */, 28 /* input width */,
2032 v12.data() /* input */, v13.data() /* output */,
2033 threadpool /* threadpool */);
2034 if (status != xnn_status_success) {
2035 std::cerr << "failed to setup operation #12" << std::endl;
2036 return ExecutionPlan();
2037 }
2038
2039 status = xnn_setup_convolution2d_nhwc_qc8(
2040 op13,
2041 1 /* batch size */, 28 /* input height */, 28 /* input width */,
2042 v13.data() /* input */, v14.data() /* output */,
2043 threadpool /* threadpool */);
2044 if (status != xnn_status_success) {
2045 std::cerr << "failed to setup operation #13" << std::endl;
2046 return ExecutionPlan();
2047 }
2048
2049 status = xnn_setup_convolution2d_nhwc_qc8(
2050 op14,
2051 1 /* batch size */, 28 /* input height */, 28 /* input width */,
2052 v14.data() /* input */, v15.data() /* output */,
2053 threadpool /* threadpool */);
2054 if (status != xnn_status_success) {
2055 std::cerr << "failed to setup operation #14" << std::endl;
2056 return ExecutionPlan();
2057 }
2058
2059 status = xnn_setup_convolution2d_nhwc_qc8(
2060 op15,
2061 1 /* batch size */, 28 /* input height */, 28 /* input width */,
2062 v15.data() /* input */, v16.data() /* output */,
2063 threadpool /* threadpool */);
2064 if (status != xnn_status_success) {
2065 std::cerr << "failed to setup operation #15" << std::endl;
2066 return ExecutionPlan();
2067 }
2068
2069 {
2070 const size_t a_shape[] = { 1, 28, 28, 32 };
2071 const size_t b_shape[] = { 1, 28, 28, 32 };
2072 status = xnn_setup_add_nd_qs8(
2073 op16,
2074 4, a_shape, 4, b_shape,
2075 v16.data() /* a */, v13.data() /* b */, v17.data() /* output */,
2076 threadpool /* threadpool */);
2077 }
2078 if (status != xnn_status_success) {
2079 std::cerr << "failed to setup operation #16" << std::endl;
2080 return ExecutionPlan();
2081 }
2082
2083 status = xnn_setup_convolution2d_nhwc_qc8(
2084 op17,
2085 1 /* batch size */, 28 /* input height */, 28 /* input width */,
2086 v17.data() /* input */, v18.data() /* output */,
2087 threadpool /* threadpool */);
2088 if (status != xnn_status_success) {
2089 std::cerr << "failed to setup operation #17" << std::endl;
2090 return ExecutionPlan();
2091 }
2092
2093 status = xnn_setup_convolution2d_nhwc_qc8(
2094 op18,
2095 1 /* batch size */, 28 /* input height */, 28 /* input width */,
2096 v18.data() /* input */, v19.data() /* output */,
2097 threadpool /* threadpool */);
2098 if (status != xnn_status_success) {
2099 std::cerr << "failed to setup operation #18" << std::endl;
2100 return ExecutionPlan();
2101 }
2102
2103 status = xnn_setup_convolution2d_nhwc_qc8(
2104 op19,
2105 1 /* batch size */, 28 /* input height */, 28 /* input width */,
2106 v19.data() /* input */, v20.data() /* output */,
2107 threadpool /* threadpool */);
2108 if (status != xnn_status_success) {
2109 std::cerr << "failed to setup operation #19" << std::endl;
2110 return ExecutionPlan();
2111 }
2112
2113 {
2114 const size_t a_shape[] = { 1, 28, 28, 32 };
2115 const size_t b_shape[] = { 1, 28, 28, 32 };
2116 status = xnn_setup_add_nd_qs8(
2117 op20,
2118 4, a_shape, 4, b_shape,
2119 v20.data() /* a */, v17.data() /* b */, v21.data() /* output */,
2120 threadpool /* threadpool */);
2121 }
2122 if (status != xnn_status_success) {
2123 std::cerr << "failed to setup operation #20" << std::endl;
2124 return ExecutionPlan();
2125 }
2126
2127 status = xnn_setup_convolution2d_nhwc_qc8(
2128 op21,
2129 1 /* batch size */, 28 /* input height */, 28 /* input width */,
2130 v21.data() /* input */, v22.data() /* output */,
2131 threadpool /* threadpool */);
2132 if (status != xnn_status_success) {
2133 std::cerr << "failed to setup operation #21" << std::endl;
2134 return ExecutionPlan();
2135 }
2136
2137 status = xnn_setup_convolution2d_nhwc_qc8(
2138 op22,
2139 1 /* batch size */, 28 /* input height */, 28 /* input width */,
2140 v22.data() /* input */, v23.data() /* output */,
2141 threadpool /* threadpool */);
2142 if (status != xnn_status_success) {
2143 std::cerr << "failed to setup operation #22" << std::endl;
2144 return ExecutionPlan();
2145 }
2146
2147 status = xnn_setup_convolution2d_nhwc_qc8(
2148 op23,
2149 1 /* batch size */, 14 /* input height */, 14 /* input width */,
2150 v23.data() /* input */, v24.data() /* output */,
2151 threadpool /* threadpool */);
2152 if (status != xnn_status_success) {
2153 std::cerr << "failed to setup operation #23" << std::endl;
2154 return ExecutionPlan();
2155 }
2156
2157 status = xnn_setup_convolution2d_nhwc_qc8(
2158 op24,
2159 1 /* batch size */, 14 /* input height */, 14 /* input width */,
2160 v24.data() /* input */, v25.data() /* output */,
2161 threadpool /* threadpool */);
2162 if (status != xnn_status_success) {
2163 std::cerr << "failed to setup operation #24" << std::endl;
2164 return ExecutionPlan();
2165 }
2166
2167 status = xnn_setup_convolution2d_nhwc_qc8(
2168 op25,
2169 1 /* batch size */, 14 /* input height */, 14 /* input width */,
2170 v25.data() /* input */, v26.data() /* output */,
2171 threadpool /* threadpool */);
2172 if (status != xnn_status_success) {
2173 std::cerr << "failed to setup operation #25" << std::endl;
2174 return ExecutionPlan();
2175 }
2176
2177 status = xnn_setup_convolution2d_nhwc_qc8(
2178 op26,
2179 1 /* batch size */, 14 /* input height */, 14 /* input width */,
2180 v26.data() /* input */, v27.data() /* output */,
2181 threadpool /* threadpool */);
2182 if (status != xnn_status_success) {
2183 std::cerr << "failed to setup operation #26" << std::endl;
2184 return ExecutionPlan();
2185 }
2186
2187 {
2188 const size_t a_shape[] = { 1, 14, 14, 64 };
2189 const size_t b_shape[] = { 1, 14, 14, 64 };
2190 status = xnn_setup_add_nd_qs8(
2191 op27,
2192 4, a_shape, 4, b_shape,
2193 v27.data() /* a */, v24.data() /* b */, v28.data() /* output */,
2194 threadpool /* threadpool */);
2195 }
2196 if (status != xnn_status_success) {
2197 std::cerr << "failed to setup operation #27" << std::endl;
2198 return ExecutionPlan();
2199 }
2200
2201 status = xnn_setup_convolution2d_nhwc_qc8(
2202 op28,
2203 1 /* batch size */, 14 /* input height */, 14 /* input width */,
2204 v28.data() /* input */, v29.data() /* output */,
2205 threadpool /* threadpool */);
2206 if (status != xnn_status_success) {
2207 std::cerr << "failed to setup operation #28" << std::endl;
2208 return ExecutionPlan();
2209 }
2210
2211 status = xnn_setup_convolution2d_nhwc_qc8(
2212 op29,
2213 1 /* batch size */, 14 /* input height */, 14 /* input width */,
2214 v29.data() /* input */, v30.data() /* output */,
2215 threadpool /* threadpool */);
2216 if (status != xnn_status_success) {
2217 std::cerr << "failed to setup operation #29" << std::endl;
2218 return ExecutionPlan();
2219 }
2220
2221 status = xnn_setup_convolution2d_nhwc_qc8(
2222 op30,
2223 1 /* batch size */, 14 /* input height */, 14 /* input width */,
2224 v30.data() /* input */, v31.data() /* output */,
2225 threadpool /* threadpool */);
2226 if (status != xnn_status_success) {
2227 std::cerr << "failed to setup operation #30" << std::endl;
2228 return ExecutionPlan();
2229 }
2230
2231 {
2232 const size_t a_shape[] = { 1, 14, 14, 64 };
2233 const size_t b_shape[] = { 1, 14, 14, 64 };
2234 status = xnn_setup_add_nd_qs8(
2235 op31,
2236 4, a_shape, 4, b_shape,
2237 v31.data() /* a */, v28.data() /* b */, v32.data() /* output */,
2238 threadpool /* threadpool */);
2239 }
2240 if (status != xnn_status_success) {
2241 std::cerr << "failed to setup operation #31" << std::endl;
2242 return ExecutionPlan();
2243 }
2244
2245 status = xnn_setup_convolution2d_nhwc_qc8(
2246 op32,
2247 1 /* batch size */, 14 /* input height */, 14 /* input width */,
2248 v32.data() /* input */, v33.data() /* output */,
2249 threadpool /* threadpool */);
2250 if (status != xnn_status_success) {
2251 std::cerr << "failed to setup operation #32" << std::endl;
2252 return ExecutionPlan();
2253 }
2254
2255 status = xnn_setup_convolution2d_nhwc_qc8(
2256 op33,
2257 1 /* batch size */, 14 /* input height */, 14 /* input width */,
2258 v33.data() /* input */, v34.data() /* output */,
2259 threadpool /* threadpool */);
2260 if (status != xnn_status_success) {
2261 std::cerr << "failed to setup operation #33" << std::endl;
2262 return ExecutionPlan();
2263 }
2264
2265 status = xnn_setup_convolution2d_nhwc_qc8(
2266 op34,
2267 1 /* batch size */, 14 /* input height */, 14 /* input width */,
2268 v34.data() /* input */, v35.data() /* output */,
2269 threadpool /* threadpool */);
2270 if (status != xnn_status_success) {
2271 std::cerr << "failed to setup operation #34" << std::endl;
2272 return ExecutionPlan();
2273 }
2274
2275 {
2276 const size_t a_shape[] = { 1, 14, 14, 64 };
2277 const size_t b_shape[] = { 1, 14, 14, 64 };
2278 status = xnn_setup_add_nd_qs8(
2279 op35,
2280 4, a_shape, 4, b_shape,
2281 v35.data() /* a */, v32.data() /* b */, v36.data() /* output */,
2282 threadpool /* threadpool */);
2283 }
2284 if (status != xnn_status_success) {
2285 std::cerr << "failed to setup operation #35" << std::endl;
2286 return ExecutionPlan();
2287 }
2288
2289 status = xnn_setup_convolution2d_nhwc_qc8(
2290 op36,
2291 1 /* batch size */, 14 /* input height */, 14 /* input width */,
2292 v36.data() /* input */, v37.data() /* output */,
2293 threadpool /* threadpool */);
2294 if (status != xnn_status_success) {
2295 std::cerr << "failed to setup operation #36" << std::endl;
2296 return ExecutionPlan();
2297 }
2298
2299 status = xnn_setup_convolution2d_nhwc_qc8(
2300 op37,
2301 1 /* batch size */, 14 /* input height */, 14 /* input width */,
2302 v37.data() /* input */, v38.data() /* output */,
2303 threadpool /* threadpool */);
2304 if (status != xnn_status_success) {
2305 std::cerr << "failed to setup operation #37" << std::endl;
2306 return ExecutionPlan();
2307 }
2308
2309 status = xnn_setup_convolution2d_nhwc_qc8(
2310 op38,
2311 1 /* batch size */, 14 /* input height */, 14 /* input width */,
2312 v38.data() /* input */, v39.data() /* output */,
2313 threadpool /* threadpool */);
2314 if (status != xnn_status_success) {
2315 std::cerr << "failed to setup operation #38" << std::endl;
2316 return ExecutionPlan();
2317 }
2318
2319 status = xnn_setup_convolution2d_nhwc_qc8(
2320 op39,
2321 1 /* batch size */, 14 /* input height */, 14 /* input width */,
2322 v39.data() /* input */, v40.data() /* output */,
2323 threadpool /* threadpool */);
2324 if (status != xnn_status_success) {
2325 std::cerr << "failed to setup operation #39" << std::endl;
2326 return ExecutionPlan();
2327 }
2328
2329 status = xnn_setup_convolution2d_nhwc_qc8(
2330 op40,
2331 1 /* batch size */, 14 /* input height */, 14 /* input width */,
2332 v40.data() /* input */, v41.data() /* output */,
2333 threadpool /* threadpool */);
2334 if (status != xnn_status_success) {
2335 std::cerr << "failed to setup operation #40" << std::endl;
2336 return ExecutionPlan();
2337 }
2338
2339 status = xnn_setup_convolution2d_nhwc_qc8(
2340 op41,
2341 1 /* batch size */, 14 /* input height */, 14 /* input width */,
2342 v41.data() /* input */, v42.data() /* output */,
2343 threadpool /* threadpool */);
2344 if (status != xnn_status_success) {
2345 std::cerr << "failed to setup operation #41" << std::endl;
2346 return ExecutionPlan();
2347 }
2348
2349 {
2350 const size_t a_shape[] = { 1, 14, 14, 96 };
2351 const size_t b_shape[] = { 1, 14, 14, 96 };
2352 status = xnn_setup_add_nd_qs8(
2353 op42,
2354 4, a_shape, 4, b_shape,
2355 v42.data() /* a */, v39.data() /* b */, v43.data() /* output */,
2356 threadpool /* threadpool */);
2357 }
2358 if (status != xnn_status_success) {
2359 std::cerr << "failed to setup operation #42" << std::endl;
2360 return ExecutionPlan();
2361 }
2362
2363 status = xnn_setup_convolution2d_nhwc_qc8(
2364 op43,
2365 1 /* batch size */, 14 /* input height */, 14 /* input width */,
2366 v43.data() /* input */, v44.data() /* output */,
2367 threadpool /* threadpool */);
2368 if (status != xnn_status_success) {
2369 std::cerr << "failed to setup operation #43" << std::endl;
2370 return ExecutionPlan();
2371 }
2372
2373 status = xnn_setup_convolution2d_nhwc_qc8(
2374 op44,
2375 1 /* batch size */, 14 /* input height */, 14 /* input width */,
2376 v44.data() /* input */, v45.data() /* output */,
2377 threadpool /* threadpool */);
2378 if (status != xnn_status_success) {
2379 std::cerr << "failed to setup operation #44" << std::endl;
2380 return ExecutionPlan();
2381 }
2382
2383 status = xnn_setup_convolution2d_nhwc_qc8(
2384 op45,
2385 1 /* batch size */, 14 /* input height */, 14 /* input width */,
2386 v45.data() /* input */, v46.data() /* output */,
2387 threadpool /* threadpool */);
2388 if (status != xnn_status_success) {
2389 std::cerr << "failed to setup operation #45" << std::endl;
2390 return ExecutionPlan();
2391 }
2392
2393 {
2394 const size_t a_shape[] = { 1, 14, 14, 96 };
2395 const size_t b_shape[] = { 1, 14, 14, 96 };
2396 status = xnn_setup_add_nd_qs8(
2397 op46,
2398 4, a_shape, 4, b_shape,
2399 v46.data() /* a */, v43.data() /* b */, v47.data() /* output */,
2400 threadpool /* threadpool */);
2401 }
2402 if (status != xnn_status_success) {
2403 std::cerr << "failed to setup operation #46" << std::endl;
2404 return ExecutionPlan();
2405 }
2406
2407 status = xnn_setup_convolution2d_nhwc_qc8(
2408 op47,
2409 1 /* batch size */, 14 /* input height */, 14 /* input width */,
2410 v47.data() /* input */, v48.data() /* output */,
2411 threadpool /* threadpool */);
2412 if (status != xnn_status_success) {
2413 std::cerr << "failed to setup operation #47" << std::endl;
2414 return ExecutionPlan();
2415 }
2416
2417 status = xnn_setup_convolution2d_nhwc_qc8(
2418 op48,
2419 1 /* batch size */, 14 /* input height */, 14 /* input width */,
2420 v48.data() /* input */, v49.data() /* output */,
2421 threadpool /* threadpool */);
2422 if (status != xnn_status_success) {
2423 std::cerr << "failed to setup operation #48" << std::endl;
2424 return ExecutionPlan();
2425 }
2426
2427 status = xnn_setup_convolution2d_nhwc_qc8(
2428 op49,
2429 1 /* batch size */, 7 /* input height */, 7 /* input width */,
2430 v49.data() /* input */, v50.data() /* output */,
2431 threadpool /* threadpool */);
2432 if (status != xnn_status_success) {
2433 std::cerr << "failed to setup operation #49" << std::endl;
2434 return ExecutionPlan();
2435 }
2436
2437 status = xnn_setup_convolution2d_nhwc_qc8(
2438 op50,
2439 1 /* batch size */, 7 /* input height */, 7 /* input width */,
2440 v50.data() /* input */, v51.data() /* output */,
2441 threadpool /* threadpool */);
2442 if (status != xnn_status_success) {
2443 std::cerr << "failed to setup operation #50" << std::endl;
2444 return ExecutionPlan();
2445 }
2446
2447 status = xnn_setup_convolution2d_nhwc_qc8(
2448 op51,
2449 1 /* batch size */, 7 /* input height */, 7 /* input width */,
2450 v51.data() /* input */, v52.data() /* output */,
2451 threadpool /* threadpool */);
2452 if (status != xnn_status_success) {
2453 std::cerr << "failed to setup operation #51" << std::endl;
2454 return ExecutionPlan();
2455 }
2456
2457 status = xnn_setup_convolution2d_nhwc_qc8(
2458 op52,
2459 1 /* batch size */, 7 /* input height */, 7 /* input width */,
2460 v52.data() /* input */, v53.data() /* output */,
2461 threadpool /* threadpool */);
2462 if (status != xnn_status_success) {
2463 std::cerr << "failed to setup operation #52" << std::endl;
2464 return ExecutionPlan();
2465 }
2466
2467 {
2468 const size_t a_shape[] = { 1, 7, 7, 160 };
2469 const size_t b_shape[] = { 1, 7, 7, 160 };
2470 status = xnn_setup_add_nd_qs8(
2471 op53,
2472 4, a_shape, 4, b_shape,
2473 v53.data() /* a */, v50.data() /* b */, v54.data() /* output */,
2474 threadpool /* threadpool */);
2475 }
2476 if (status != xnn_status_success) {
2477 std::cerr << "failed to setup operation #53" << std::endl;
2478 return ExecutionPlan();
2479 }
2480
2481 status = xnn_setup_convolution2d_nhwc_qc8(
2482 op54,
2483 1 /* batch size */, 7 /* input height */, 7 /* input width */,
2484 v54.data() /* input */, v55.data() /* output */,
2485 threadpool /* threadpool */);
2486 if (status != xnn_status_success) {
2487 std::cerr << "failed to setup operation #54" << std::endl;
2488 return ExecutionPlan();
2489 }
2490
2491 status = xnn_setup_convolution2d_nhwc_qc8(
2492 op55,
2493 1 /* batch size */, 7 /* input height */, 7 /* input width */,
2494 v55.data() /* input */, v56.data() /* output */,
2495 threadpool /* threadpool */);
2496 if (status != xnn_status_success) {
2497 std::cerr << "failed to setup operation #55" << std::endl;
2498 return ExecutionPlan();
2499 }
2500
2501 status = xnn_setup_convolution2d_nhwc_qc8(
2502 op56,
2503 1 /* batch size */, 7 /* input height */, 7 /* input width */,
2504 v56.data() /* input */, v57.data() /* output */,
2505 threadpool /* threadpool */);
2506 if (status != xnn_status_success) {
2507 std::cerr << "failed to setup operation #56" << std::endl;
2508 return ExecutionPlan();
2509 }
2510
2511 {
2512 const size_t a_shape[] = { 1, 7, 7, 160 };
2513 const size_t b_shape[] = { 1, 7, 7, 160 };
2514 status = xnn_setup_add_nd_qs8(
2515 op57,
2516 4, a_shape, 4, b_shape,
2517 v57.data() /* a */, v54.data() /* b */, v58.data() /* output */,
2518 threadpool /* threadpool */);
2519 }
2520 if (status != xnn_status_success) {
2521 std::cerr << "failed to setup operation #57" << std::endl;
2522 return ExecutionPlan();
2523 }
2524
2525 status = xnn_setup_convolution2d_nhwc_qc8(
2526 op58,
2527 1 /* batch size */, 7 /* input height */, 7 /* input width */,
2528 v58.data() /* input */, v59.data() /* output */,
2529 threadpool /* threadpool */);
2530 if (status != xnn_status_success) {
2531 std::cerr << "failed to setup operation #58" << std::endl;
2532 return ExecutionPlan();
2533 }
2534
2535 status = xnn_setup_convolution2d_nhwc_qc8(
2536 op59,
2537 1 /* batch size */, 7 /* input height */, 7 /* input width */,
2538 v59.data() /* input */, v60.data() /* output */,
2539 threadpool /* threadpool */);
2540 if (status != xnn_status_success) {
2541 std::cerr << "failed to setup operation #59" << std::endl;
2542 return ExecutionPlan();
2543 }
2544
2545 status = xnn_setup_convolution2d_nhwc_qc8(
2546 op60,
2547 1 /* batch size */, 7 /* input height */, 7 /* input width */,
2548 v60.data() /* input */, v61.data() /* output */,
2549 threadpool /* threadpool */);
2550 if (status != xnn_status_success) {
2551 std::cerr << "failed to setup operation #60" << std::endl;
2552 return ExecutionPlan();
2553 }
2554
2555 status = xnn_setup_convolution2d_nhwc_qc8(
2556 op61,
2557 1 /* batch size */, 7 /* input height */, 7 /* input width */,
2558 v61.data() /* input */, v62.data() /* output */,
2559 threadpool /* threadpool */);
2560 if (status != xnn_status_success) {
2561 std::cerr << "failed to setup operation #61" << std::endl;
2562 return ExecutionPlan();
2563 }
2564
2565 status = xnn_setup_global_average_pooling_nwc_qs8(
2566 op62,
2567 1 /* batch size */, 49 /* width */,
2568 v62.data() /* input */, v63.data() /* output */,
2569 threadpool /* threadpool */);
2570 if (status != xnn_status_success) {
2571 std::cerr << "failed to setup operation #62" << std::endl;
2572 return ExecutionPlan();
2573 }
2574
2575 status = xnn_setup_convolution2d_nhwc_qc8(
2576 op63,
2577 1 /* batch size */, 1 /* input height */, 1 /* input width */,
2578 v63.data() /* input */, v64.data() /* output */,
2579 threadpool /* threadpool */);
2580 if (status != xnn_status_success) {
2581 std::cerr << "failed to setup operation #63" << std::endl;
2582 return ExecutionPlan();
2583 }
2584
2585 #pragma clang diagnostic push
2586 #pragma clang diagnostic ignored "-Wpessimizing-move"
2587 return operators;
2588 #pragma clang diagnostic pop
2589 }
2590
2591 } // namespace models
2592