Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / XNNPACK / refs/tags/rel/11/fp3/8901.4.A.0017.3 / . / models / mobilenet-v3-large.cc
blob: 1c169264e3f7d36f19839b08753c77d653fc2445 [file] [log] [blame]
Marat Dukhanc08cdf52019-12-09 09:17:51 -0800[diff] [blame]1// Copyright 2019 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 <algorithm>
9#include <functional>
10#include <iostream>
11#include <limits>
12#include <random>
13
14#include "models/models.h"
15
16namespace models {
17
18ExecutionPlan MobileNetV3Large(pthreadpool_t threadpool) {
19 alignas(16) static float v0[150528];
20 alignas(16) static float v1[200704];
21 alignas(16) static float v2[200704];
22 alignas(16) static float v3[200704];
23 alignas(16) static float v4[200704];
24 alignas(16) static float v5[200704];
25 alignas(16) static float v6[802816];
26 alignas(16) static float v7[200704];
27 alignas(16) static float v8[75264];
28 alignas(16) static float v9[225792];
29 alignas(16) static float v10[225792];
30 alignas(16) static float v11[75264];
31 alignas(16) static float v12[75264];
32 alignas(16) static float v13[225792];
33 alignas(16) static float v14[56448];
34 alignas(16) static float v15[72];
35 alignas(16) static float v16[24];
36 alignas(16) static float v17[72];
37 alignas(16) static float v18[56448];
38 alignas(16) static float v19[31360];
39 alignas(16) static float v20[94080];
40 alignas(16) static float v21[94080];
41 alignas(16) static float v22[120];
42 alignas(16) static float v23[32];
43 alignas(16) static float v24[120];
44 alignas(16) static float v25[94080];
45 alignas(16) static float v26[31360];
46 alignas(16) static float v27[31360];
47 alignas(16) static float v28[94080];
48 alignas(16) static float v29[94080];
49 alignas(16) static float v30[120];
50 alignas(16) static float v31[32];
51 alignas(16) static float v32[120];
52 alignas(16) static float v33[94080];
53 alignas(16) static float v34[31360];
54 alignas(16) static float v35[31360];
55 alignas(16) static float v36[188160];
56 alignas(16) static float v37[188160];
57 alignas(16) static float v38[47040];
58 alignas(16) static float v39[47040];
59 alignas(16) static float v40[15680];
60 alignas(16) static float v41[39200];
61 alignas(16) static float v42[39200];
62 alignas(16) static float v43[39200];
63 alignas(16) static float v44[39200];
64 alignas(16) static float v45[15680];
65 alignas(16) static float v46[15680];
66 alignas(16) static float v47[36064];
67 alignas(16) static float v48[36064];
68 alignas(16) static float v49[36064];
69 alignas(16) static float v50[36064];
70 alignas(16) static float v51[15680];
71 alignas(16) static float v52[15680];
72 alignas(16) static float v53[36064];
73 alignas(16) static float v54[36064];
74 alignas(16) static float v55[36064];
75 alignas(16) static float v56[36064];
76 alignas(16) static float v57[15680];
77 alignas(16) static float v58[15680];
78 alignas(16) static float v59[94080];
79 alignas(16) static float v60[94080];
80 alignas(16) static float v61[94080];
81 alignas(16) static float v62[94080];
82 alignas(16) static float v63[480];
83 alignas(16) static float v64[120];
84 alignas(16) static float v65[480];
85 alignas(16) static float v66[94080];
86 alignas(16) static float v67[21952];
87 alignas(16) static float v68[131712];
88 alignas(16) static float v69[131712];
89 alignas(16) static float v70[131712];
90 alignas(16) static float v71[131712];
91 alignas(16) static float v72[672];
92 alignas(16) static float v73[168];
93 alignas(16) static float v74[672];
94 alignas(16) static float v75[131712];
95 alignas(16) static float v76[21952];
96 alignas(16) static float v77[21952];
97 alignas(16) static float v78[131712];
98 alignas(16) static float v79[131712];
99 alignas(16) static float v80[32928];
100 alignas(16) static float v81[32928];
101 alignas(16) static float v82[672];
102 alignas(16) static float v83[168];
103 alignas(16) static float v84[672];
104 alignas(16) static float v85[32928];
105 alignas(16) static float v86[7840];
106 alignas(16) static float v87[47040];
107 alignas(16) static float v88[47040];
108 alignas(16) static float v89[47040];
109 alignas(16) static float v90[47040];
110 alignas(16) static float v91[960];
111 alignas(16) static float v92[240];
112 alignas(16) static float v93[960];
113 alignas(16) static float v94[47040];
114 alignas(16) static float v95[7840];
115 alignas(16) static float v96[7840];
116 alignas(16) static float v97[47040];
117 alignas(16) static float v98[47040];
118 alignas(16) static float v99[47040];
119 alignas(16) static float v100[47040];
120 alignas(16) static float v101[960];
121 alignas(16) static float v102[240];
122 alignas(16) static float v103[960];
123 alignas(16) static float v104[47040];
124 alignas(16) static float v105[7840];
125 alignas(16) static float v106[7840];
126 alignas(16) static float v107[47040];
127 alignas(16) static float v108[47040];
128 alignas(16) static float v109[960];
129 alignas(16) static float v110[1280];
130 alignas(16) static float v111[1280];
131 alignas(16) static float v112[1280];
132 alignas(16) static float v113[1001];
133 alignas(16) static float w114[432];
134 alignas(16) static float w115[16];
135 alignas(16) static float w116[144];
136 alignas(16) static float w117[16];
137 alignas(16) static float w118[256];
138 alignas(16) static float w119[16];
139 alignas(16) static float w120[1024];
140 alignas(16) static float w121[64];
141 alignas(16) static float w122[576];
142 alignas(16) static float w123[64];
143 alignas(16) static float w124[1536];
144 alignas(16) static float w125[24];
145 alignas(16) static float w126[1728];
146 alignas(16) static float w127[72];
147 alignas(16) static float w128[648];
148 alignas(16) static float w129[72];
149 alignas(16) static float w130[1728];
150 alignas(16) static float w131[24];
151 alignas(16) static float w132[1728];
152 alignas(16) static float w133[72];
153 alignas(16) static float w134[1800];
154 alignas(16) static float w135[72];
155 alignas(16) static float w136[1728];
156 alignas(16) static float w137[24];
157 alignas(16) static float w138[1728];
158 alignas(16) static float w139[72];
159 alignas(16) static float w140[2880];
160 alignas(16) static float w141[40];
161 alignas(16) static float w142[4800];
162 alignas(16) static float w143[120];
163 alignas(16) static float w144[3000];
164 alignas(16) static float w145[120];
165 alignas(16) static float w146[3840];
166 alignas(16) static float w147[32];
167 alignas(16) static float w148[3840];
168 alignas(16) static float w149[120];
169 alignas(16) static float w150[4800];
170 alignas(16) static float w151[40];
171 alignas(16) static float w152[4800];
172 alignas(16) static float w153[120];
173 alignas(16) static float w154[3000];
174 alignas(16) static float w155[120];
175 alignas(16) static float w156[3840];
176 alignas(16) static float w157[32];
177 alignas(16) static float w158[3840];
178 alignas(16) static float w159[120];
179 alignas(16) static float w160[4800];
180 alignas(16) static float w161[40];
181 alignas(16) static float w162[9600];
182 alignas(16) static float w163[240];
183 alignas(16) static float w164[2160];
184 alignas(16) static float w165[240];
185 alignas(16) static float w166[19200];
186 alignas(16) static float w167[80];
187 alignas(16) static float w168[16000];
188 alignas(16) static float w169[200];
189 alignas(16) static float w170[1800];
190 alignas(16) static float w171[200];
191 alignas(16) static float w172[16000];
192 alignas(16) static float w173[80];
193 alignas(16) static float w174[14720];
194 alignas(16) static float w175[184];
195 alignas(16) static float w176[1656];
196 alignas(16) static float w177[184];
197 alignas(16) static float w178[14720];
198 alignas(16) static float w179[80];
199 alignas(16) static float w180[14720];
200 alignas(16) static float w181[184];
201 alignas(16) static float w182[1656];
202 alignas(16) static float w183[184];
203 alignas(16) static float w184[14720];
204 alignas(16) static float w185[80];
205 alignas(16) static float w186[38400];
206 alignas(16) static float w187[480];
207 alignas(16) static float w188[4320];
208 alignas(16) static float w189[480];
209 alignas(16) static float w190[57600];
210 alignas(16) static float w191[120];
211 alignas(16) static float w192[57600];
212 alignas(16) static float w193[480];
213 alignas(16) static float w194[53760];
214 alignas(16) static float w195[112];
215 alignas(16) static float w196[75264];
216 alignas(16) static float w197[672];
217 alignas(16) static float w198[6048];
218 alignas(16) static float w199[672];
219 alignas(16) static float w200[112896];
220 alignas(16) static float w201[168];
221 alignas(16) static float w202[112896];
222 alignas(16) static float w203[672];
223 alignas(16) static float w204[75264];
224 alignas(16) static float w205[112];
225 alignas(16) static float w206[75264];
226 alignas(16) static float w207[672];
227 alignas(16) static float w208[16800];
228 alignas(16) static float w209[672];
229 alignas(16) static float w210[112896];
230 alignas(16) static float w211[168];
231 alignas(16) static float w212[112896];
232 alignas(16) static float w213[672];
233 alignas(16) static float w214[107520];
234 alignas(16) static float w215[160];
235 alignas(16) static float w216[153600];
236 alignas(16) static float w217[960];
237 alignas(16) static float w218[24000];
238 alignas(16) static float w219[960];
239 alignas(16) static float w220[230400];
240 alignas(16) static float w221[240];
241 alignas(16) static float w222[230400];
242 alignas(16) static float w223[960];
243 alignas(16) static float w224[153600];
244 alignas(16) static float w225[160];
245 alignas(16) static float w226[153600];
246 alignas(16) static float w227[960];
247 alignas(16) static float w228[24000];
248 alignas(16) static float w229[960];
249 alignas(16) static float w230[230400];
250 alignas(16) static float w231[240];
251 alignas(16) static float w232[230400];
252 alignas(16) static float w233[960];
253 alignas(16) static float w234[153600];
254 alignas(16) static float w235[160];
255 alignas(16) static float w236[153600];
256 alignas(16) static float w237[960];
257 alignas(16) static float w238[1228800];
258 alignas(16) static float w239[1280];
259 alignas(16) static float w240[1281280];
260 alignas(16) static float w241[1001];
261
262 std::random_device random_device;
263 auto rng = std::mt19937(random_device());
264 auto f32rng = std::bind(std::uniform_real_distribution<float>(-1.0f, +1.0f), rng);
265 std::generate(v0, v0 + 150528, std::ref(f32rng));
266 std::generate(w114, w114 + 432, std::ref(f32rng));
267 std::generate(w115, w115 + 16, std::ref(f32rng));
268 std::generate(w116, w116 + 144, std::ref(f32rng));
269 std::generate(w117, w117 + 16, std::ref(f32rng));
270 std::generate(w118, w118 + 256, std::ref(f32rng));
271 std::generate(w119, w119 + 16, std::ref(f32rng));
272 std::generate(w120, w120 + 1024, std::ref(f32rng));
273 std::generate(w121, w121 + 64, std::ref(f32rng));
274 std::generate(w122, w122 + 576, std::ref(f32rng));
275 std::generate(w123, w123 + 64, std::ref(f32rng));
276 std::generate(w124, w124 + 1536, std::ref(f32rng));
277 std::generate(w125, w125 + 24, std::ref(f32rng));
278 std::generate(w126, w126 + 1728, std::ref(f32rng));
279 std::generate(w127, w127 + 72, std::ref(f32rng));
280 std::generate(w128, w128 + 648, std::ref(f32rng));
281 std::generate(w129, w129 + 72, std::ref(f32rng));
282 std::generate(w130, w130 + 1728, std::ref(f32rng));
283 std::generate(w131, w131 + 24, std::ref(f32rng));
284 std::generate(w132, w132 + 1728, std::ref(f32rng));
285 std::generate(w133, w133 + 72, std::ref(f32rng));
286 std::generate(w134, w134 + 1800, std::ref(f32rng));
287 std::generate(w135, w135 + 72, std::ref(f32rng));
288 std::generate(w136, w136 + 1728, std::ref(f32rng));
289 std::generate(w137, w137 + 24, std::ref(f32rng));
290 std::generate(w138, w138 + 1728, std::ref(f32rng));
291 std::generate(w139, w139 + 72, std::ref(f32rng));
292 std::generate(w140, w140 + 2880, std::ref(f32rng));
293 std::generate(w141, w141 + 40, std::ref(f32rng));
294 std::generate(w142, w142 + 4800, std::ref(f32rng));
295 std::generate(w143, w143 + 120, std::ref(f32rng));
296 std::generate(w144, w144 + 3000, std::ref(f32rng));
297 std::generate(w145, w145 + 120, std::ref(f32rng));
298 std::generate(w146, w146 + 3840, std::ref(f32rng));
299 std::generate(w147, w147 + 32, std::ref(f32rng));
300 std::generate(w148, w148 + 3840, std::ref(f32rng));
301 std::generate(w149, w149 + 120, std::ref(f32rng));
302 std::generate(w150, w150 + 4800, std::ref(f32rng));
303 std::generate(w151, w151 + 40, std::ref(f32rng));
304 std::generate(w152, w152 + 4800, std::ref(f32rng));
305 std::generate(w153, w153 + 120, std::ref(f32rng));
306 std::generate(w154, w154 + 3000, std::ref(f32rng));
307 std::generate(w155, w155 + 120, std::ref(f32rng));
308 std::generate(w156, w156 + 3840, std::ref(f32rng));
309 std::generate(w157, w157 + 32, std::ref(f32rng));
310 std::generate(w158, w158 + 3840, std::ref(f32rng));
311 std::generate(w159, w159 + 120, std::ref(f32rng));
312 std::generate(w160, w160 + 4800, std::ref(f32rng));
313 std::generate(w161, w161 + 40, std::ref(f32rng));
314 std::generate(w162, w162 + 9600, std::ref(f32rng));
315 std::generate(w163, w163 + 240, std::ref(f32rng));
316 std::generate(w164, w164 + 2160, std::ref(f32rng));
317 std::generate(w165, w165 + 240, std::ref(f32rng));
318 std::generate(w166, w166 + 19200, std::ref(f32rng));
319 std::generate(w167, w167 + 80, std::ref(f32rng));
320 std::generate(w168, w168 + 16000, std::ref(f32rng));
321 std::generate(w169, w169 + 200, std::ref(f32rng));
322 std::generate(w170, w170 + 1800, std::ref(f32rng));
323 std::generate(w171, w171 + 200, std::ref(f32rng));
324 std::generate(w172, w172 + 16000, std::ref(f32rng));
325 std::generate(w173, w173 + 80, std::ref(f32rng));
326 std::generate(w174, w174 + 14720, std::ref(f32rng));
327 std::generate(w175, w175 + 184, std::ref(f32rng));
328 std::generate(w176, w176 + 1656, std::ref(f32rng));
329 std::generate(w177, w177 + 184, std::ref(f32rng));
330 std::generate(w178, w178 + 14720, std::ref(f32rng));
331 std::generate(w179, w179 + 80, std::ref(f32rng));
332 std::generate(w180, w180 + 14720, std::ref(f32rng));
333 std::generate(w181, w181 + 184, std::ref(f32rng));
334 std::generate(w182, w182 + 1656, std::ref(f32rng));
335 std::generate(w183, w183 + 184, std::ref(f32rng));
336 std::generate(w184, w184 + 14720, std::ref(f32rng));
337 std::generate(w185, w185 + 80, std::ref(f32rng));
338 std::generate(w186, w186 + 38400, std::ref(f32rng));
339 std::generate(w187, w187 + 480, std::ref(f32rng));
340 std::generate(w188, w188 + 4320, std::ref(f32rng));
341 std::generate(w189, w189 + 480, std::ref(f32rng));
342 std::generate(w190, w190 + 57600, std::ref(f32rng));
343 std::generate(w191, w191 + 120, std::ref(f32rng));
344 std::generate(w192, w192 + 57600, std::ref(f32rng));
345 std::generate(w193, w193 + 480, std::ref(f32rng));
346 std::generate(w194, w194 + 53760, std::ref(f32rng));
347 std::generate(w195, w195 + 112, std::ref(f32rng));
348 std::generate(w196, w196 + 75264, std::ref(f32rng));
349 std::generate(w197, w197 + 672, std::ref(f32rng));
350 std::generate(w198, w198 + 6048, std::ref(f32rng));
351 std::generate(w199, w199 + 672, std::ref(f32rng));
352 std::generate(w200, w200 + 112896, std::ref(f32rng));
353 std::generate(w201, w201 + 168, std::ref(f32rng));
354 std::generate(w202, w202 + 112896, std::ref(f32rng));
355 std::generate(w203, w203 + 672, std::ref(f32rng));
356 std::generate(w204, w204 + 75264, std::ref(f32rng));
357 std::generate(w205, w205 + 112, std::ref(f32rng));
358 std::generate(w206, w206 + 75264, std::ref(f32rng));
359 std::generate(w207, w207 + 672, std::ref(f32rng));
360 std::generate(w208, w208 + 16800, std::ref(f32rng));
361 std::generate(w209, w209 + 672, std::ref(f32rng));
362 std::generate(w210, w210 + 112896, std::ref(f32rng));
363 std::generate(w211, w211 + 168, std::ref(f32rng));
364 std::generate(w212, w212 + 112896, std::ref(f32rng));
365 std::generate(w213, w213 + 672, std::ref(f32rng));
366 std::generate(w214, w214 + 107520, std::ref(f32rng));
367 std::generate(w215, w215 + 160, std::ref(f32rng));
368 std::generate(w216, w216 + 153600, std::ref(f32rng));
369 std::generate(w217, w217 + 960, std::ref(f32rng));
370 std::generate(w218, w218 + 24000, std::ref(f32rng));
371 std::generate(w219, w219 + 960, std::ref(f32rng));
372 std::generate(w220, w220 + 230400, std::ref(f32rng));
373 std::generate(w221, w221 + 240, std::ref(f32rng));
374 std::generate(w222, w222 + 230400, std::ref(f32rng));
375 std::generate(w223, w223 + 960, std::ref(f32rng));
376 std::generate(w224, w224 + 153600, std::ref(f32rng));
377 std::generate(w225, w225 + 160, std::ref(f32rng));
378 std::generate(w226, w226 + 153600, std::ref(f32rng));
379 std::generate(w227, w227 + 960, std::ref(f32rng));
380 std::generate(w228, w228 + 24000, std::ref(f32rng));
381 std::generate(w229, w229 + 960, std::ref(f32rng));
382 std::generate(w230, w230 + 230400, std::ref(f32rng));
383 std::generate(w231, w231 + 240, std::ref(f32rng));
384 std::generate(w232, w232 + 230400, std::ref(f32rng));
385 std::generate(w233, w233 + 960, std::ref(f32rng));
386 std::generate(w234, w234 + 153600, std::ref(f32rng));
387 std::generate(w235, w235 + 160, std::ref(f32rng));
388 std::generate(w236, w236 + 153600, std::ref(f32rng));
389 std::generate(w237, w237 + 960, std::ref(f32rng));
390 std::generate(w238, w238 + 1228800, std::ref(f32rng));
391 std::generate(w239, w239 + 1280, std::ref(f32rng));
392 std::generate(w240, w240 + 1281280, std::ref(f32rng));
393 std::generate(w241, w241 + 1001, std::ref(f32rng));
394
395 ExecutionPlan operators;
396 xnn_status status;
397
398 xnn_operator_t op0 = nullptr;
399 status = xnn_create_convolution2d_nhwc_f32(
400 0 /* top padding */, 1 /* right padding */,
401 1 /* bottom padding */, 0 /* left padding */,
402 3 /* kernel height */, 3 /* kernel width */,
403 2 /* subsampling height */, 2 /* subsampling width */,
404 1 /* dilation_height */, 1 /* dilation_width */,
405 1 /* groups */,
406 3 /* input channels per group */,
407 16 /* output_channels_per_group */,
408 3 /* input pixel stride */,
409 16 /* output pixel stride */,
410 w114, w115,
411 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
412 0 /* flags */,
413 &op0);
414 if (status != xnn_status_success) {
415 std::cerr << "failed to create operation #0" << std::endl;
416 return ExecutionPlan();
417 }
418 operators.emplace_back(op0, xnn_delete_operator);
419
420 xnn_operator_t op1 = nullptr;
421 status = xnn_create_hardswish_nc_f32(
422 16 /* channels */,
423 16 /* input stride */,
424 16 /* output stride */,
425 0 /* flags */,
426 &op1);
427 if (status != xnn_status_success) {
428 std::cerr << "failed to create operation #1" << std::endl;
429 return ExecutionPlan();
430 }
431 operators.emplace_back(op1, xnn_delete_operator);
432
433 xnn_operator_t op2 = nullptr;
434 status = xnn_create_convolution2d_nhwc_f32(
435 1 /* top padding */, 1 /* right padding */,
436 1 /* bottom padding */, 1 /* left padding */,
437 3 /* kernel height */, 3 /* kernel width */,
438 1 /* subsampling height */, 1 /* subsampling width */,
439 1 /* dilation_height */, 1 /* dilation_width */,
440 16 /* groups */,
441 1 /* input channels per group */,
442 1 /* output_channels_per_group */,
443 16 /* input pixel stride */,
444 16 /* output pixel stride */,
445 w116, w117,
446 0.0f /* output min */, std::numeric_limits<float>::infinity() /* output max */,
447 0 /* flags */,
448 &op2);
449 if (status != xnn_status_success) {
450 std::cerr << "failed to create operation #2" << std::endl;
451 return ExecutionPlan();
452 }
453 operators.emplace_back(op2, xnn_delete_operator);
454
455 xnn_operator_t op3 = nullptr;
456 status = xnn_create_convolution2d_nhwc_f32(
457 0 /* top padding */, 0 /* right padding */,
458 0 /* bottom padding */, 0 /* left padding */,
459 1 /* kernel height */, 1 /* kernel width */,
460 1 /* subsampling height */, 1 /* subsampling width */,
461 1 /* dilation_height */, 1 /* dilation_width */,
462 1 /* groups */,
463 16 /* input channels per group */,
464 16 /* output_channels_per_group */,
465 16 /* input pixel stride */,
466 16 /* output pixel stride */,
467 w118, w119,
468 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
469 0 /* flags */,
470 &op3);
471 if (status != xnn_status_success) {
472 std::cerr << "failed to create operation #3" << std::endl;
473 return ExecutionPlan();
474 }
475 operators.emplace_back(op3, xnn_delete_operator);
476
477 xnn_operator_t op4 = nullptr;
478 status = xnn_create_add_nc_f32(
479 16 /* channels */,
480 16 /* a stride */,
481 16 /* b stride */,
482 16 /* c stride */,
483 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
484 0 /* flags */,
485 &op4);
486 if (status != xnn_status_success) {
487 std::cerr << "failed to create operation #4" << std::endl;
488 return ExecutionPlan();
489 }
490 operators.emplace_back(op4, xnn_delete_operator);
491
492 xnn_operator_t op5 = nullptr;
493 status = xnn_create_convolution2d_nhwc_f32(
494 0 /* top padding */, 0 /* right padding */,
495 0 /* bottom padding */, 0 /* left padding */,
496 1 /* kernel height */, 1 /* kernel width */,
497 1 /* subsampling height */, 1 /* subsampling width */,
498 1 /* dilation_height */, 1 /* dilation_width */,
499 1 /* groups */,
500 16 /* input channels per group */,
501 64 /* output_channels_per_group */,
502 16 /* input pixel stride */,
503 64 /* output pixel stride */,
504 w120, w121,
505 0.0f /* output min */, std::numeric_limits<float>::infinity() /* output max */,
506 0 /* flags */,
507 &op5);
508 if (status != xnn_status_success) {
509 std::cerr << "failed to create operation #5" << std::endl;
510 return ExecutionPlan();
511 }
512 operators.emplace_back(op5, xnn_delete_operator);
513
514 xnn_operator_t op6 = nullptr;
515 status = xnn_create_convolution2d_nhwc_f32(
516 0 /* top padding */, 1 /* right padding */,
517 1 /* bottom padding */, 0 /* left padding */,
518 3 /* kernel height */, 3 /* kernel width */,
519 2 /* subsampling height */, 2 /* subsampling width */,
520 1 /* dilation_height */, 1 /* dilation_width */,
521 64 /* groups */,
522 1 /* input channels per group */,
523 1 /* output_channels_per_group */,
524 64 /* input pixel stride */,
525 64 /* output pixel stride */,
526 w122, w123,
527 0.0f /* output min */, std::numeric_limits<float>::infinity() /* output max */,
528 0 /* flags */,
529 &op6);
530 if (status != xnn_status_success) {
531 std::cerr << "failed to create operation #6" << std::endl;
532 return ExecutionPlan();
533 }
534 operators.emplace_back(op6, xnn_delete_operator);
535
536 xnn_operator_t op7 = nullptr;
537 status = xnn_create_convolution2d_nhwc_f32(
538 0 /* top padding */, 0 /* right padding */,
539 0 /* bottom padding */, 0 /* left padding */,
540 1 /* kernel height */, 1 /* kernel width */,
541 1 /* subsampling height */, 1 /* subsampling width */,
542 1 /* dilation_height */, 1 /* dilation_width */,
543 1 /* groups */,
544 64 /* input channels per group */,
545 24 /* output_channels_per_group */,
546 64 /* input pixel stride */,
547 24 /* output pixel stride */,
548 w124, w125,
549 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
550 0 /* flags */,
551 &op7);
552 if (status != xnn_status_success) {
553 std::cerr << "failed to create operation #7" << std::endl;
554 return ExecutionPlan();
555 }
556 operators.emplace_back(op7, xnn_delete_operator);
557
558 xnn_operator_t op8 = nullptr;
559 status = xnn_create_convolution2d_nhwc_f32(
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 24 /* input channels per group */,
567 72 /* output_channels_per_group */,
568 24 /* input pixel stride */,
569 72 /* output pixel stride */,
570 w126, w127,
571 0.0f /* output min */, std::numeric_limits<float>::infinity() /* output max */,
572 0 /* flags */,
573 &op8);
574 if (status != xnn_status_success) {
575 std::cerr << "failed to create operation #8" << std::endl;
576 return ExecutionPlan();
577 }
578 operators.emplace_back(op8, xnn_delete_operator);
579
580 xnn_operator_t op9 = nullptr;
581 status = xnn_create_convolution2d_nhwc_f32(
582 1 /* top padding */, 1 /* right padding */,
583 1 /* bottom padding */, 1 /* left padding */,
584 3 /* kernel height */, 3 /* kernel width */,
585 1 /* subsampling height */, 1 /* subsampling width */,
586 1 /* dilation_height */, 1 /* dilation_width */,
587 72 /* groups */,
588 1 /* input channels per group */,
589 1 /* output_channels_per_group */,
590 72 /* input pixel stride */,
591 72 /* output pixel stride */,
592 w128, w129,
593 0.0f /* output min */, std::numeric_limits<float>::infinity() /* output max */,
594 0 /* flags */,
595 &op9);
596 if (status != xnn_status_success) {
597 std::cerr << "failed to create operation #9" << std::endl;
598 return ExecutionPlan();
599 }
600 operators.emplace_back(op9, xnn_delete_operator);
601
602 xnn_operator_t op10 = nullptr;
603 status = xnn_create_convolution2d_nhwc_f32(
604 0 /* top padding */, 0 /* right padding */,
605 0 /* bottom padding */, 0 /* left padding */,
606 1 /* kernel height */, 1 /* kernel width */,
607 1 /* subsampling height */, 1 /* subsampling width */,
608 1 /* dilation_height */, 1 /* dilation_width */,
609 1 /* groups */,
610 72 /* input channels per group */,
611 24 /* output_channels_per_group */,
612 72 /* input pixel stride */,
613 24 /* output pixel stride */,
614 w130, w131,
615 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
616 0 /* flags */,
617 &op10);
618 if (status != xnn_status_success) {
619 std::cerr << "failed to create operation #10" << std::endl;
620 return ExecutionPlan();
621 }
622 operators.emplace_back(op10, xnn_delete_operator);
623
624 xnn_operator_t op11 = nullptr;
625 status = xnn_create_add_nc_f32(
626 24 /* channels */,
627 24 /* a stride */,
628 24 /* b stride */,
629 24 /* c stride */,
630 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
631 0 /* flags */,
632 &op11);
633 if (status != xnn_status_success) {
634 std::cerr << "failed to create operation #11" << std::endl;
635 return ExecutionPlan();
636 }
637 operators.emplace_back(op11, xnn_delete_operator);
638
639 xnn_operator_t op12 = nullptr;
640 status = xnn_create_convolution2d_nhwc_f32(
641 0 /* top padding */, 0 /* right padding */,
642 0 /* bottom padding */, 0 /* left padding */,
643 1 /* kernel height */, 1 /* kernel width */,
644 1 /* subsampling height */, 1 /* subsampling width */,
645 1 /* dilation_height */, 1 /* dilation_width */,
646 1 /* groups */,
647 24 /* input channels per group */,
648 72 /* output_channels_per_group */,
649 24 /* input pixel stride */,
650 72 /* output pixel stride */,
651 w132, w133,
652 0.0f /* output min */, std::numeric_limits<float>::infinity() /* output max */,
653 0 /* flags */,
654 &op12);
655 if (status != xnn_status_success) {
656 std::cerr << "failed to create operation #12" << std::endl;
657 return ExecutionPlan();
658 }
659 operators.emplace_back(op12, xnn_delete_operator);
660
661 xnn_operator_t op13 = nullptr;
662 status = xnn_create_convolution2d_nhwc_f32(
663 1 /* top padding */, 2 /* right padding */,
664 2 /* bottom padding */, 1 /* left padding */,
665 5 /* kernel height */, 5 /* kernel width */,
666 2 /* subsampling height */, 2 /* subsampling width */,
667 1 /* dilation_height */, 1 /* dilation_width */,
668 72 /* groups */,
669 1 /* input channels per group */,
670 1 /* output_channels_per_group */,
671 72 /* input pixel stride */,
672 72 /* output pixel stride */,
673 w134, w135,
674 0.0f /* output min */, std::numeric_limits<float>::infinity() /* output max */,
675 0 /* flags */,
676 &op13);
677 if (status != xnn_status_success) {
678 std::cerr << "failed to create operation #13" << std::endl;
679 return ExecutionPlan();
680 }
681 operators.emplace_back(op13, xnn_delete_operator);
682
683 xnn_operator_t op14 = nullptr;
684 status = xnn_create_global_average_pooling_nwc_f32(
685 72 /* channels */, 72 /* input stride */, 72 /* output stride */,
686 -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
687 0 /* flags */,
688 &op14);
689 if (status != xnn_status_success) {
690 std::cerr << "failed to create operation #14" << std::endl;
691 return ExecutionPlan();
692 }
693 operators.emplace_back(op14, xnn_delete_operator);
694
695 xnn_operator_t op15 = nullptr;
696 status = xnn_create_convolution2d_nhwc_f32(
697 0 /* top padding */, 0 /* right padding */,
698 0 /* bottom padding */, 0 /* left padding */,
699 1 /* kernel height */, 1 /* kernel width */,
700 1 /* subsampling height */, 1 /* subsampling width */,
701 1 /* dilation_height */, 1 /* dilation_width */,
702 1 /* groups */,
703 72 /* input channels per group */,
704 24 /* output_channels_per_group */,
705 72 /* input pixel stride */,
706 24 /* output pixel stride */,
707 w136, w137,
708 0.0f /* output min */, std::numeric_limits<float>::infinity() /* output max */,
709 0 /* flags */,
710 &op15);
711 if (status != xnn_status_success) {
712 std::cerr << "failed to create operation #15" << std::endl;
713 return ExecutionPlan();
714 }
715 operators.emplace_back(op15, xnn_delete_operator);
716
717 xnn_operator_t op16 = nullptr;
718 status = xnn_create_convolution2d_nhwc_f32(
719 0 /* top padding */, 0 /* right padding */,
720 0 /* bottom padding */, 0 /* left padding */,
721 1 /* kernel height */, 1 /* kernel width */,
722 1 /* subsampling height */, 1 /* subsampling width */,
723 1 /* dilation_height */, 1 /* dilation_width */,
724 1 /* groups */,
725 24 /* input channels per group */,
726 72 /* output_channels_per_group */,
727 24 /* input pixel stride */,
728 72 /* output pixel stride */,
729 w138, w139,
730 0.0f /* output min */, +0x1.00014Fp+0 /* output max */,
731 0 /* flags */,
732 &op16);
733 if (status != xnn_status_success) {
734 std::cerr << "failed to create operation #16" << std::endl;
735 return ExecutionPlan();
736 }
737 operators.emplace_back(op16, xnn_delete_operator);
738
739 xnn_operator_t op17 = nullptr;
740 status = xnn_create_multiply_nd_f32(
741 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
742 0 /* flags */,
743 &op17);
744 if (status != xnn_status_success) {
745 std::cerr << "failed to create operation #17" << std::endl;
746 return ExecutionPlan();
747 }
748 operators.emplace_back(op17, xnn_delete_operator);
749
750 xnn_operator_t op18 = nullptr;
751 status = xnn_create_convolution2d_nhwc_f32(
752 0 /* top padding */, 0 /* right padding */,
753 0 /* bottom padding */, 0 /* left padding */,
754 1 /* kernel height */, 1 /* kernel width */,
755 1 /* subsampling height */, 1 /* subsampling width */,
756 1 /* dilation_height */, 1 /* dilation_width */,
757 1 /* groups */,
758 72 /* input channels per group */,
759 40 /* output_channels_per_group */,
760 72 /* input pixel stride */,
761 40 /* output pixel stride */,
762 w140, w141,
763 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
764 0 /* flags */,
765 &op18);
766 if (status != xnn_status_success) {
767 std::cerr << "failed to create operation #18" << std::endl;
768 return ExecutionPlan();
769 }
770 operators.emplace_back(op18, xnn_delete_operator);
771
772 xnn_operator_t op19 = nullptr;
773 status = xnn_create_convolution2d_nhwc_f32(
774 0 /* top padding */, 0 /* right padding */,
775 0 /* bottom padding */, 0 /* left padding */,
776 1 /* kernel height */, 1 /* kernel width */,
777 1 /* subsampling height */, 1 /* subsampling width */,
778 1 /* dilation_height */, 1 /* dilation_width */,
779 1 /* groups */,
780 40 /* input channels per group */,
781 120 /* output_channels_per_group */,
782 40 /* input pixel stride */,
783 120 /* output pixel stride */,
784 w142, w143,
785 0.0f /* output min */, std::numeric_limits<float>::infinity() /* output max */,
786 0 /* flags */,
787 &op19);
788 if (status != xnn_status_success) {
789 std::cerr << "failed to create operation #19" << std::endl;
790 return ExecutionPlan();
791 }
792 operators.emplace_back(op19, xnn_delete_operator);
793
794 xnn_operator_t op20 = nullptr;
795 status = xnn_create_convolution2d_nhwc_f32(
796 2 /* top padding */, 2 /* right padding */,
797 2 /* bottom padding */, 2 /* left padding */,
798 5 /* kernel height */, 5 /* kernel width */,
799 1 /* subsampling height */, 1 /* subsampling width */,
800 1 /* dilation_height */, 1 /* dilation_width */,
801 120 /* groups */,
802 1 /* input channels per group */,
803 1 /* output_channels_per_group */,
804 120 /* input pixel stride */,
805 120 /* output pixel stride */,
806 w144, w145,
807 0.0f /* output min */, std::numeric_limits<float>::infinity() /* output max */,
808 0 /* flags */,
809 &op20);
810 if (status != xnn_status_success) {
811 std::cerr << "failed to create operation #20" << std::endl;
812 return ExecutionPlan();
813 }
814 operators.emplace_back(op20, xnn_delete_operator);
815
816 xnn_operator_t op21 = nullptr;
817 status = xnn_create_global_average_pooling_nwc_f32(
818 120 /* channels */, 120 /* input stride */, 120 /* output stride */,
819 -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
820 0 /* flags */,
821 &op21);
822 if (status != xnn_status_success) {
823 std::cerr << "failed to create operation #21" << std::endl;
824 return ExecutionPlan();
825 }
826 operators.emplace_back(op21, xnn_delete_operator);
827
828 xnn_operator_t op22 = nullptr;
829 status = xnn_create_convolution2d_nhwc_f32(
830 0 /* top padding */, 0 /* right padding */,
831 0 /* bottom padding */, 0 /* left padding */,
832 1 /* kernel height */, 1 /* kernel width */,
833 1 /* subsampling height */, 1 /* subsampling width */,
834 1 /* dilation_height */, 1 /* dilation_width */,
835 1 /* groups */,
836 120 /* input channels per group */,
837 32 /* output_channels_per_group */,
838 120 /* input pixel stride */,
839 32 /* output pixel stride */,
840 w146, w147,
841 0.0f /* output min */, std::numeric_limits<float>::infinity() /* output max */,
842 0 /* flags */,
843 &op22);
844 if (status != xnn_status_success) {
845 std::cerr << "failed to create operation #22" << std::endl;
846 return ExecutionPlan();
847 }
848 operators.emplace_back(op22, xnn_delete_operator);
849
850 xnn_operator_t op23 = nullptr;
851 status = xnn_create_convolution2d_nhwc_f32(
852 0 /* top padding */, 0 /* right padding */,
853 0 /* bottom padding */, 0 /* left padding */,
854 1 /* kernel height */, 1 /* kernel width */,
855 1 /* subsampling height */, 1 /* subsampling width */,
856 1 /* dilation_height */, 1 /* dilation_width */,
857 1 /* groups */,
858 32 /* input channels per group */,
859 120 /* output_channels_per_group */,
860 32 /* input pixel stride */,
861 120 /* output pixel stride */,
862 w148, w149,
863 0.0f /* output min */, +0x1.00014Fp+0 /* output max */,
864 0 /* flags */,
865 &op23);
866 if (status != xnn_status_success) {
867 std::cerr << "failed to create operation #23" << std::endl;
868 return ExecutionPlan();
869 }
870 operators.emplace_back(op23, xnn_delete_operator);
871
872 xnn_operator_t op24 = nullptr;
873 status = xnn_create_multiply_nd_f32(
874 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
875 0 /* flags */,
876 &op24);
877 if (status != xnn_status_success) {
878 std::cerr << "failed to create operation #24" << std::endl;
879 return ExecutionPlan();
880 }
881 operators.emplace_back(op24, xnn_delete_operator);
882
883 xnn_operator_t op25 = nullptr;
884 status = xnn_create_convolution2d_nhwc_f32(
885 0 /* top padding */, 0 /* right padding */,
886 0 /* bottom padding */, 0 /* left padding */,
887 1 /* kernel height */, 1 /* kernel width */,
888 1 /* subsampling height */, 1 /* subsampling width */,
889 1 /* dilation_height */, 1 /* dilation_width */,
890 1 /* groups */,
891 120 /* input channels per group */,
892 40 /* output_channels_per_group */,
893 120 /* input pixel stride */,
894 40 /* output pixel stride */,
895 w150, w151,
896 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
897 0 /* flags */,
898 &op25);
899 if (status != xnn_status_success) {
900 std::cerr << "failed to create operation #25" << std::endl;
901 return ExecutionPlan();
902 }
903 operators.emplace_back(op25, xnn_delete_operator);
904
905 xnn_operator_t op26 = nullptr;
906 status = xnn_create_add_nc_f32(
907 40 /* channels */,
908 40 /* a stride */,
909 40 /* b stride */,
910 40 /* c stride */,
911 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
912 0 /* flags */,
913 &op26);
914 if (status != xnn_status_success) {
915 std::cerr << "failed to create operation #26" << std::endl;
916 return ExecutionPlan();
917 }
918 operators.emplace_back(op26, xnn_delete_operator);
919
920 xnn_operator_t op27 = nullptr;
921 status = xnn_create_convolution2d_nhwc_f32(
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 40 /* input channels per group */,
929 120 /* output_channels_per_group */,
930 40 /* input pixel stride */,
931 120 /* output pixel stride */,
932 w152, w153,
933 0.0f /* output min */, std::numeric_limits<float>::infinity() /* output max */,
934 0 /* flags */,
935 &op27);
936 if (status != xnn_status_success) {
937 std::cerr << "failed to create operation #27" << std::endl;
938 return ExecutionPlan();
939 }
940 operators.emplace_back(op27, xnn_delete_operator);
941
942 xnn_operator_t op28 = nullptr;
943 status = xnn_create_convolution2d_nhwc_f32(
944 2 /* top padding */, 2 /* right padding */,
945 2 /* bottom padding */, 2 /* left padding */,
946 5 /* kernel height */, 5 /* kernel width */,
947 1 /* subsampling height */, 1 /* subsampling width */,
948 1 /* dilation_height */, 1 /* dilation_width */,
949 120 /* groups */,
950 1 /* input channels per group */,
951 1 /* output_channels_per_group */,
952 120 /* input pixel stride */,
953 120 /* output pixel stride */,
954 w154, w155,
955 0.0f /* output min */, std::numeric_limits<float>::infinity() /* output max */,
956 0 /* flags */,
957 &op28);
958 if (status != xnn_status_success) {
959 std::cerr << "failed to create operation #28" << std::endl;
960 return ExecutionPlan();
961 }
962 operators.emplace_back(op28, xnn_delete_operator);
963
964 xnn_operator_t op29 = nullptr;
965 status = xnn_create_global_average_pooling_nwc_f32(
966 120 /* channels */, 120 /* input stride */, 120 /* output stride */,
967 -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
968 0 /* flags */,
969 &op29);
970 if (status != xnn_status_success) {
971 std::cerr << "failed to create operation #29" << std::endl;
972 return ExecutionPlan();
973 }
974 operators.emplace_back(op29, xnn_delete_operator);
975
976 xnn_operator_t op30 = nullptr;
977 status = xnn_create_convolution2d_nhwc_f32(
978 0 /* top padding */, 0 /* right padding */,
979 0 /* bottom padding */, 0 /* left padding */,
980 1 /* kernel height */, 1 /* kernel width */,
981 1 /* subsampling height */, 1 /* subsampling width */,
982 1 /* dilation_height */, 1 /* dilation_width */,
983 1 /* groups */,
984 120 /* input channels per group */,
985 32 /* output_channels_per_group */,
986 120 /* input pixel stride */,
987 32 /* output pixel stride */,
988 w156, w157,
989 0.0f /* output min */, std::numeric_limits<float>::infinity() /* output max */,
990 0 /* flags */,
991 &op30);
992 if (status != xnn_status_success) {
993 std::cerr << "failed to create operation #30" << std::endl;
994 return ExecutionPlan();
995 }
996 operators.emplace_back(op30, xnn_delete_operator);
997
998 xnn_operator_t op31 = nullptr;
999 status = xnn_create_convolution2d_nhwc_f32(
1000 0 /* top padding */, 0 /* right padding */,
1001 0 /* bottom padding */, 0 /* left padding */,
1002 1 /* kernel height */, 1 /* kernel width */,
1003 1 /* subsampling height */, 1 /* subsampling width */,
1004 1 /* dilation_height */, 1 /* dilation_width */,
1005 1 /* groups */,
1006 32 /* input channels per group */,
1007 120 /* output_channels_per_group */,
1008 32 /* input pixel stride */,
1009 120 /* output pixel stride */,
1010 w158, w159,
1011 0.0f /* output min */, +0x1.00014Fp+0 /* output max */,
1012 0 /* flags */,
1013 &op31);
1014 if (status != xnn_status_success) {
1015 std::cerr << "failed to create operation #31" << std::endl;
1016 return ExecutionPlan();
1017 }
1018 operators.emplace_back(op31, xnn_delete_operator);
1019
1020 xnn_operator_t op32 = nullptr;
1021 status = xnn_create_multiply_nd_f32(
1022 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1023 0 /* flags */,
1024 &op32);
1025 if (status != xnn_status_success) {
1026 std::cerr << "failed to create operation #32" << std::endl;
1027 return ExecutionPlan();
1028 }
1029 operators.emplace_back(op32, xnn_delete_operator);
1030
1031 xnn_operator_t op33 = nullptr;
1032 status = xnn_create_convolution2d_nhwc_f32(
1033 0 /* top padding */, 0 /* right padding */,
1034 0 /* bottom padding */, 0 /* left padding */,
1035 1 /* kernel height */, 1 /* kernel width */,
1036 1 /* subsampling height */, 1 /* subsampling width */,
1037 1 /* dilation_height */, 1 /* dilation_width */,
1038 1 /* groups */,
1039 120 /* input channels per group */,
1040 40 /* output_channels_per_group */,
1041 120 /* input pixel stride */,
1042 40 /* output pixel stride */,
1043 w160, w161,
1044 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1045 0 /* flags */,
1046 &op33);
1047 if (status != xnn_status_success) {
1048 std::cerr << "failed to create operation #33" << std::endl;
1049 return ExecutionPlan();
1050 }
1051 operators.emplace_back(op33, xnn_delete_operator);
1052
1053 xnn_operator_t op34 = nullptr;
1054 status = xnn_create_add_nc_f32(
1055 40 /* channels */,
1056 40 /* a stride */,
1057 40 /* b stride */,
1058 40 /* c stride */,
1059 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1060 0 /* flags */,
1061 &op34);
1062 if (status != xnn_status_success) {
1063 std::cerr << "failed to create operation #34" << std::endl;
1064 return ExecutionPlan();
1065 }
1066 operators.emplace_back(op34, xnn_delete_operator);
1067
1068 xnn_operator_t op35 = nullptr;
1069 status = xnn_create_convolution2d_nhwc_f32(
1070 0 /* top padding */, 0 /* right padding */,
1071 0 /* bottom padding */, 0 /* left padding */,
1072 1 /* kernel height */, 1 /* kernel width */,
1073 1 /* subsampling height */, 1 /* subsampling width */,
1074 1 /* dilation_height */, 1 /* dilation_width */,
1075 1 /* groups */,
1076 40 /* input channels per group */,
1077 240 /* output_channels_per_group */,
1078 40 /* input pixel stride */,
1079 240 /* output pixel stride */,
1080 w162, w163,
1081 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1082 0 /* flags */,
1083 &op35);
1084 if (status != xnn_status_success) {
1085 std::cerr << "failed to create operation #35" << std::endl;
1086 return ExecutionPlan();
1087 }
1088 operators.emplace_back(op35, xnn_delete_operator);
1089
1090 xnn_operator_t op36 = nullptr;
1091 status = xnn_create_hardswish_nc_f32(
1092 240 /* channels */,
1093 240 /* input stride */,
1094 240 /* output stride */,
1095 0 /* flags */,
1096 &op36);
1097 if (status != xnn_status_success) {
1098 std::cerr << "failed to create operation #36" << std::endl;
1099 return ExecutionPlan();
1100 }
1101 operators.emplace_back(op36, xnn_delete_operator);
1102
1103 xnn_operator_t op37 = nullptr;
1104 status = xnn_create_convolution2d_nhwc_f32(
1105 0 /* top padding */, 1 /* right padding */,
1106 1 /* bottom padding */, 0 /* left padding */,
1107 3 /* kernel height */, 3 /* kernel width */,
1108 2 /* subsampling height */, 2 /* subsampling width */,
1109 1 /* dilation_height */, 1 /* dilation_width */,
1110 240 /* groups */,
1111 1 /* input channels per group */,
1112 1 /* output_channels_per_group */,
1113 240 /* input pixel stride */,
1114 240 /* output pixel stride */,
1115 w164, w165,
1116 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1117 0 /* flags */,
1118 &op37);
1119 if (status != xnn_status_success) {
1120 std::cerr << "failed to create operation #37" << std::endl;
1121 return ExecutionPlan();
1122 }
1123 operators.emplace_back(op37, xnn_delete_operator);
1124
1125 xnn_operator_t op38 = nullptr;
1126 status = xnn_create_hardswish_nc_f32(
1127 240 /* channels */,
1128 240 /* input stride */,
1129 240 /* output stride */,
1130 0 /* flags */,
1131 &op38);
1132 if (status != xnn_status_success) {
1133 std::cerr << "failed to create operation #38" << std::endl;
1134 return ExecutionPlan();
1135 }
1136 operators.emplace_back(op38, xnn_delete_operator);
1137
1138 xnn_operator_t op39 = nullptr;
1139 status = xnn_create_convolution2d_nhwc_f32(
1140 0 /* top padding */, 0 /* right padding */,
1141 0 /* bottom padding */, 0 /* left padding */,
1142 1 /* kernel height */, 1 /* kernel width */,
1143 1 /* subsampling height */, 1 /* subsampling width */,
1144 1 /* dilation_height */, 1 /* dilation_width */,
1145 1 /* groups */,
1146 240 /* input channels per group */,
1147 80 /* output_channels_per_group */,
1148 240 /* input pixel stride */,
1149 80 /* output pixel stride */,
1150 w166, w167,
1151 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1152 0 /* flags */,
1153 &op39);
1154 if (status != xnn_status_success) {
1155 std::cerr << "failed to create operation #39" << std::endl;
1156 return ExecutionPlan();
1157 }
1158 operators.emplace_back(op39, xnn_delete_operator);
1159
1160 xnn_operator_t op40 = nullptr;
1161 status = xnn_create_convolution2d_nhwc_f32(
1162 0 /* top padding */, 0 /* right padding */,
1163 0 /* bottom padding */, 0 /* left padding */,
1164 1 /* kernel height */, 1 /* kernel width */,
1165 1 /* subsampling height */, 1 /* subsampling width */,
1166 1 /* dilation_height */, 1 /* dilation_width */,
1167 1 /* groups */,
1168 80 /* input channels per group */,
1169 200 /* output_channels_per_group */,
1170 80 /* input pixel stride */,
1171 200 /* output pixel stride */,
1172 w168, w169,
1173 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1174 0 /* flags */,
1175 &op40);
1176 if (status != xnn_status_success) {
1177 std::cerr << "failed to create operation #40" << std::endl;
1178 return ExecutionPlan();
1179 }
1180 operators.emplace_back(op40, xnn_delete_operator);
1181
1182 xnn_operator_t op41 = nullptr;
1183 status = xnn_create_hardswish_nc_f32(
1184 200 /* channels */,
1185 200 /* input stride */,
1186 200 /* output stride */,
1187 0 /* flags */,
1188 &op41);
1189 if (status != xnn_status_success) {
1190 std::cerr << "failed to create operation #41" << std::endl;
1191 return ExecutionPlan();
1192 }
1193 operators.emplace_back(op41, xnn_delete_operator);
1194
1195 xnn_operator_t op42 = nullptr;
1196 status = xnn_create_convolution2d_nhwc_f32(
1197 1 /* top padding */, 1 /* right padding */,
1198 1 /* bottom padding */, 1 /* left padding */,
1199 3 /* kernel height */, 3 /* kernel width */,
1200 1 /* subsampling height */, 1 /* subsampling width */,
1201 1 /* dilation_height */, 1 /* dilation_width */,
1202 200 /* groups */,
1203 1 /* input channels per group */,
1204 1 /* output_channels_per_group */,
1205 200 /* input pixel stride */,
1206 200 /* output pixel stride */,
1207 w170, w171,
1208 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1209 0 /* flags */,
1210 &op42);
1211 if (status != xnn_status_success) {
1212 std::cerr << "failed to create operation #42" << std::endl;
1213 return ExecutionPlan();
1214 }
1215 operators.emplace_back(op42, xnn_delete_operator);
1216
1217 xnn_operator_t op43 = nullptr;
1218 status = xnn_create_hardswish_nc_f32(
1219 200 /* channels */,
1220 200 /* input stride */,
1221 200 /* output stride */,
1222 0 /* flags */,
1223 &op43);
1224 if (status != xnn_status_success) {
1225 std::cerr << "failed to create operation #43" << std::endl;
1226 return ExecutionPlan();
1227 }
1228 operators.emplace_back(op43, xnn_delete_operator);
1229
1230 xnn_operator_t op44 = nullptr;
1231 status = xnn_create_convolution2d_nhwc_f32(
1232 0 /* top padding */, 0 /* right padding */,
1233 0 /* bottom padding */, 0 /* left padding */,
1234 1 /* kernel height */, 1 /* kernel width */,
1235 1 /* subsampling height */, 1 /* subsampling width */,
1236 1 /* dilation_height */, 1 /* dilation_width */,
1237 1 /* groups */,
1238 200 /* input channels per group */,
1239 80 /* output_channels_per_group */,
1240 200 /* input pixel stride */,
1241 80 /* output pixel stride */,
1242 w172, w173,
1243 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1244 0 /* flags */,
1245 &op44);
1246 if (status != xnn_status_success) {
1247 std::cerr << "failed to create operation #44" << std::endl;
1248 return ExecutionPlan();
1249 }
1250 operators.emplace_back(op44, xnn_delete_operator);
1251
1252 xnn_operator_t op45 = nullptr;
1253 status = xnn_create_add_nc_f32(
1254 80 /* channels */,
1255 80 /* a stride */,
1256 80 /* b stride */,
1257 80 /* c stride */,
1258 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1259 0 /* flags */,
1260 &op45);
1261 if (status != xnn_status_success) {
1262 std::cerr << "failed to create operation #45" << std::endl;
1263 return ExecutionPlan();
1264 }
1265 operators.emplace_back(op45, xnn_delete_operator);
1266
1267 xnn_operator_t op46 = nullptr;
1268 status = xnn_create_convolution2d_nhwc_f32(
1269 0 /* top padding */, 0 /* right padding */,
1270 0 /* bottom padding */, 0 /* left padding */,
1271 1 /* kernel height */, 1 /* kernel width */,
1272 1 /* subsampling height */, 1 /* subsampling width */,
1273 1 /* dilation_height */, 1 /* dilation_width */,
1274 1 /* groups */,
1275 80 /* input channels per group */,
1276 184 /* output_channels_per_group */,
1277 80 /* input pixel stride */,
1278 184 /* output pixel stride */,
1279 w174, w175,
1280 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1281 0 /* flags */,
1282 &op46);
1283 if (status != xnn_status_success) {
1284 std::cerr << "failed to create operation #46" << std::endl;
1285 return ExecutionPlan();
1286 }
1287 operators.emplace_back(op46, xnn_delete_operator);
1288
1289 xnn_operator_t op47 = nullptr;
1290 status = xnn_create_hardswish_nc_f32(
1291 184 /* channels */,
1292 184 /* input stride */,
1293 184 /* output stride */,
1294 0 /* flags */,
1295 &op47);
1296 if (status != xnn_status_success) {
1297 std::cerr << "failed to create operation #47" << std::endl;
1298 return ExecutionPlan();
1299 }
1300 operators.emplace_back(op47, xnn_delete_operator);
1301
1302 xnn_operator_t op48 = nullptr;
1303 status = xnn_create_convolution2d_nhwc_f32(
1304 1 /* top padding */, 1 /* right padding */,
1305 1 /* bottom padding */, 1 /* left padding */,
1306 3 /* kernel height */, 3 /* kernel width */,
1307 1 /* subsampling height */, 1 /* subsampling width */,
1308 1 /* dilation_height */, 1 /* dilation_width */,
1309 184 /* groups */,
1310 1 /* input channels per group */,
1311 1 /* output_channels_per_group */,
1312 184 /* input pixel stride */,
1313 184 /* output pixel stride */,
1314 w176, w177,
1315 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1316 0 /* flags */,
1317 &op48);
1318 if (status != xnn_status_success) {
1319 std::cerr << "failed to create operation #48" << std::endl;
1320 return ExecutionPlan();
1321 }
1322 operators.emplace_back(op48, xnn_delete_operator);
1323
1324 xnn_operator_t op49 = nullptr;
1325 status = xnn_create_hardswish_nc_f32(
1326 184 /* channels */,
1327 184 /* input stride */,
1328 184 /* output stride */,
1329 0 /* flags */,
1330 &op49);
1331 if (status != xnn_status_success) {
1332 std::cerr << "failed to create operation #49" << std::endl;
1333 return ExecutionPlan();
1334 }
1335 operators.emplace_back(op49, xnn_delete_operator);
1336
1337 xnn_operator_t op50 = nullptr;
1338 status = xnn_create_convolution2d_nhwc_f32(
1339 0 /* top padding */, 0 /* right padding */,
1340 0 /* bottom padding */, 0 /* left padding */,
1341 1 /* kernel height */, 1 /* kernel width */,
1342 1 /* subsampling height */, 1 /* subsampling width */,
1343 1 /* dilation_height */, 1 /* dilation_width */,
1344 1 /* groups */,
1345 184 /* input channels per group */,
1346 80 /* output_channels_per_group */,
1347 184 /* input pixel stride */,
1348 80 /* output pixel stride */,
1349 w178, w179,
1350 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1351 0 /* flags */,
1352 &op50);
1353 if (status != xnn_status_success) {
1354 std::cerr << "failed to create operation #50" << std::endl;
1355 return ExecutionPlan();
1356 }
1357 operators.emplace_back(op50, xnn_delete_operator);
1358
1359 xnn_operator_t op51 = nullptr;
1360 status = xnn_create_add_nc_f32(
1361 80 /* channels */,
1362 80 /* a stride */,
1363 80 /* b stride */,
1364 80 /* c stride */,
1365 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1366 0 /* flags */,
1367 &op51);
1368 if (status != xnn_status_success) {
1369 std::cerr << "failed to create operation #51" << std::endl;
1370 return ExecutionPlan();
1371 }
1372 operators.emplace_back(op51, xnn_delete_operator);
1373
1374 xnn_operator_t op52 = nullptr;
1375 status = xnn_create_convolution2d_nhwc_f32(
1376 0 /* top padding */, 0 /* right padding */,
1377 0 /* bottom padding */, 0 /* left padding */,
1378 1 /* kernel height */, 1 /* kernel width */,
1379 1 /* subsampling height */, 1 /* subsampling width */,
1380 1 /* dilation_height */, 1 /* dilation_width */,
1381 1 /* groups */,
1382 80 /* input channels per group */,
1383 184 /* output_channels_per_group */,
1384 80 /* input pixel stride */,
1385 184 /* output pixel stride */,
1386 w180, w181,
1387 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1388 0 /* flags */,
1389 &op52);
1390 if (status != xnn_status_success) {
1391 std::cerr << "failed to create operation #52" << std::endl;
1392 return ExecutionPlan();
1393 }
1394 operators.emplace_back(op52, xnn_delete_operator);
1395
1396 xnn_operator_t op53 = nullptr;
1397 status = xnn_create_hardswish_nc_f32(
1398 184 /* channels */,
1399 184 /* input stride */,
1400 184 /* output stride */,
1401 0 /* flags */,
1402 &op53);
1403 if (status != xnn_status_success) {
1404 std::cerr << "failed to create operation #53" << std::endl;
1405 return ExecutionPlan();
1406 }
1407 operators.emplace_back(op53, xnn_delete_operator);
1408
1409 xnn_operator_t op54 = nullptr;
1410 status = xnn_create_convolution2d_nhwc_f32(
1411 1 /* top padding */, 1 /* right padding */,
1412 1 /* bottom padding */, 1 /* left padding */,
1413 3 /* kernel height */, 3 /* kernel width */,
1414 1 /* subsampling height */, 1 /* subsampling width */,
1415 1 /* dilation_height */, 1 /* dilation_width */,
1416 184 /* groups */,
1417 1 /* input channels per group */,
1418 1 /* output_channels_per_group */,
1419 184 /* input pixel stride */,
1420 184 /* output pixel stride */,
1421 w182, w183,
1422 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1423 0 /* flags */,
1424 &op54);
1425 if (status != xnn_status_success) {
1426 std::cerr << "failed to create operation #54" << std::endl;
1427 return ExecutionPlan();
1428 }
1429 operators.emplace_back(op54, xnn_delete_operator);
1430
1431 xnn_operator_t op55 = nullptr;
1432 status = xnn_create_hardswish_nc_f32(
1433 184 /* channels */,
1434 184 /* input stride */,
1435 184 /* output stride */,
1436 0 /* flags */,
1437 &op55);
1438 if (status != xnn_status_success) {
1439 std::cerr << "failed to create operation #55" << std::endl;
1440 return ExecutionPlan();
1441 }
1442 operators.emplace_back(op55, xnn_delete_operator);
1443
1444 xnn_operator_t op56 = nullptr;
1445 status = xnn_create_convolution2d_nhwc_f32(
1446 0 /* top padding */, 0 /* right padding */,
1447 0 /* bottom padding */, 0 /* left padding */,
1448 1 /* kernel height */, 1 /* kernel width */,
1449 1 /* subsampling height */, 1 /* subsampling width */,
1450 1 /* dilation_height */, 1 /* dilation_width */,
1451 1 /* groups */,
1452 184 /* input channels per group */,
1453 80 /* output_channels_per_group */,
1454 184 /* input pixel stride */,
1455 80 /* output pixel stride */,
1456 w184, w185,
1457 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1458 0 /* flags */,
1459 &op56);
1460 if (status != xnn_status_success) {
1461 std::cerr << "failed to create operation #56" << std::endl;
1462 return ExecutionPlan();
1463 }
1464 operators.emplace_back(op56, xnn_delete_operator);
1465
1466 xnn_operator_t op57 = nullptr;
1467 status = xnn_create_add_nc_f32(
1468 80 /* channels */,
1469 80 /* a stride */,
1470 80 /* b stride */,
1471 80 /* c stride */,
1472 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1473 0 /* flags */,
1474 &op57);
1475 if (status != xnn_status_success) {
1476 std::cerr << "failed to create operation #57" << std::endl;
1477 return ExecutionPlan();
1478 }
1479 operators.emplace_back(op57, xnn_delete_operator);
1480
1481 xnn_operator_t op58 = nullptr;
1482 status = xnn_create_convolution2d_nhwc_f32(
1483 0 /* top padding */, 0 /* right padding */,
1484 0 /* bottom padding */, 0 /* left padding */,
1485 1 /* kernel height */, 1 /* kernel width */,
1486 1 /* subsampling height */, 1 /* subsampling width */,
1487 1 /* dilation_height */, 1 /* dilation_width */,
1488 1 /* groups */,
1489 80 /* input channels per group */,
1490 480 /* output_channels_per_group */,
1491 80 /* input pixel stride */,
1492 480 /* output pixel stride */,
1493 w186, w187,
1494 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1495 0 /* flags */,
1496 &op58);
1497 if (status != xnn_status_success) {
1498 std::cerr << "failed to create operation #58" << std::endl;
1499 return ExecutionPlan();
1500 }
1501 operators.emplace_back(op58, xnn_delete_operator);
1502
1503 xnn_operator_t op59 = nullptr;
1504 status = xnn_create_hardswish_nc_f32(
1505 480 /* channels */,
1506 480 /* input stride */,
1507 480 /* output stride */,
1508 0 /* flags */,
1509 &op59);
1510 if (status != xnn_status_success) {
1511 std::cerr << "failed to create operation #59" << std::endl;
1512 return ExecutionPlan();
1513 }
1514 operators.emplace_back(op59, xnn_delete_operator);
1515
1516 xnn_operator_t op60 = nullptr;
1517 status = xnn_create_convolution2d_nhwc_f32(
1518 1 /* top padding */, 1 /* right padding */,
1519 1 /* bottom padding */, 1 /* left padding */,
1520 3 /* kernel height */, 3 /* kernel width */,
1521 1 /* subsampling height */, 1 /* subsampling width */,
1522 1 /* dilation_height */, 1 /* dilation_width */,
1523 480 /* groups */,
1524 1 /* input channels per group */,
1525 1 /* output_channels_per_group */,
1526 480 /* input pixel stride */,
1527 480 /* output pixel stride */,
1528 w188, w189,
1529 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1530 0 /* flags */,
1531 &op60);
1532 if (status != xnn_status_success) {
1533 std::cerr << "failed to create operation #60" << std::endl;
1534 return ExecutionPlan();
1535 }
1536 operators.emplace_back(op60, xnn_delete_operator);
1537
1538 xnn_operator_t op61 = nullptr;
1539 status = xnn_create_hardswish_nc_f32(
1540 480 /* channels */,
1541 480 /* input stride */,
1542 480 /* output stride */,
1543 0 /* flags */,
1544 &op61);
1545 if (status != xnn_status_success) {
1546 std::cerr << "failed to create operation #61" << std::endl;
1547 return ExecutionPlan();
1548 }
1549 operators.emplace_back(op61, xnn_delete_operator);
1550
1551 xnn_operator_t op62 = nullptr;
1552 status = xnn_create_global_average_pooling_nwc_f32(
1553 480 /* channels */, 480 /* input stride */, 480 /* output stride */,
1554 -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
1555 0 /* flags */,
1556 &op62);
1557 if (status != xnn_status_success) {
1558 std::cerr << "failed to create operation #62" << std::endl;
1559 return ExecutionPlan();
1560 }
1561 operators.emplace_back(op62, xnn_delete_operator);
1562
1563 xnn_operator_t op63 = nullptr;
1564 status = xnn_create_convolution2d_nhwc_f32(
1565 0 /* top padding */, 0 /* right padding */,
1566 0 /* bottom padding */, 0 /* left padding */,
1567 1 /* kernel height */, 1 /* kernel width */,
1568 1 /* subsampling height */, 1 /* subsampling width */,
1569 1 /* dilation_height */, 1 /* dilation_width */,
1570 1 /* groups */,
1571 480 /* input channels per group */,
1572 120 /* output_channels_per_group */,
1573 480 /* input pixel stride */,
1574 120 /* output pixel stride */,
1575 w190, w191,
1576 0.0f /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1577 0 /* flags */,
1578 &op63);
1579 if (status != xnn_status_success) {
1580 std::cerr << "failed to create operation #63" << std::endl;
1581 return ExecutionPlan();
1582 }
1583 operators.emplace_back(op63, xnn_delete_operator);
1584
1585 xnn_operator_t op64 = nullptr;
1586 status = xnn_create_convolution2d_nhwc_f32(
1587 0 /* top padding */, 0 /* right padding */,
1588 0 /* bottom padding */, 0 /* left padding */,
1589 1 /* kernel height */, 1 /* kernel width */,
1590 1 /* subsampling height */, 1 /* subsampling width */,
1591 1 /* dilation_height */, 1 /* dilation_width */,
1592 1 /* groups */,
1593 120 /* input channels per group */,
1594 480 /* output_channels_per_group */,
1595 120 /* input pixel stride */,
1596 480 /* output pixel stride */,
1597 w192, w193,
1598 0.0f /* output min */, +0x1.00014Fp+0 /* output max */,
1599 0 /* flags */,
1600 &op64);
1601 if (status != xnn_status_success) {
1602 std::cerr << "failed to create operation #64" << std::endl;
1603 return ExecutionPlan();
1604 }
1605 operators.emplace_back(op64, xnn_delete_operator);
1606
1607 xnn_operator_t op65 = nullptr;
1608 status = xnn_create_multiply_nd_f32(
1609 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1610 0 /* flags */,
1611 &op65);
1612 if (status != xnn_status_success) {
1613 std::cerr << "failed to create operation #65" << std::endl;
1614 return ExecutionPlan();
1615 }
1616 operators.emplace_back(op65, xnn_delete_operator);
1617
1618 xnn_operator_t op66 = nullptr;
1619 status = xnn_create_convolution2d_nhwc_f32(
1620 0 /* top padding */, 0 /* right padding */,
1621 0 /* bottom padding */, 0 /* left padding */,
1622 1 /* kernel height */, 1 /* kernel width */,
1623 1 /* subsampling height */, 1 /* subsampling width */,
1624 1 /* dilation_height */, 1 /* dilation_width */,
1625 1 /* groups */,
1626 480 /* input channels per group */,
1627 112 /* output_channels_per_group */,
1628 480 /* input pixel stride */,
1629 112 /* output pixel stride */,
1630 w194, w195,
1631 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1632 0 /* flags */,
1633 &op66);
1634 if (status != xnn_status_success) {
1635 std::cerr << "failed to create operation #66" << std::endl;
1636 return ExecutionPlan();
1637 }
1638 operators.emplace_back(op66, xnn_delete_operator);
1639
1640 xnn_operator_t op67 = nullptr;
1641 status = xnn_create_convolution2d_nhwc_f32(
1642 0 /* top padding */, 0 /* right padding */,
1643 0 /* bottom padding */, 0 /* left padding */,
1644 1 /* kernel height */, 1 /* kernel width */,
1645 1 /* subsampling height */, 1 /* subsampling width */,
1646 1 /* dilation_height */, 1 /* dilation_width */,
1647 1 /* groups */,
1648 112 /* input channels per group */,
1649 672 /* output_channels_per_group */,
1650 112 /* input pixel stride */,
1651 672 /* output pixel stride */,
1652 w196, w197,
1653 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1654 0 /* flags */,
1655 &op67);
1656 if (status != xnn_status_success) {
1657 std::cerr << "failed to create operation #67" << std::endl;
1658 return ExecutionPlan();
1659 }
1660 operators.emplace_back(op67, xnn_delete_operator);
1661
1662 xnn_operator_t op68 = nullptr;
1663 status = xnn_create_hardswish_nc_f32(
1664 672 /* channels */,
1665 672 /* input stride */,
1666 672 /* output stride */,
1667 0 /* flags */,
1668 &op68);
1669 if (status != xnn_status_success) {
1670 std::cerr << "failed to create operation #68" << std::endl;
1671 return ExecutionPlan();
1672 }
1673 operators.emplace_back(op68, xnn_delete_operator);
1674
1675 xnn_operator_t op69 = nullptr;
1676 status = xnn_create_convolution2d_nhwc_f32(
1677 1 /* top padding */, 1 /* right padding */,
1678 1 /* bottom padding */, 1 /* left padding */,
1679 3 /* kernel height */, 3 /* kernel width */,
1680 1 /* subsampling height */, 1 /* subsampling width */,
1681 1 /* dilation_height */, 1 /* dilation_width */,
1682 672 /* groups */,
1683 1 /* input channels per group */,
1684 1 /* output_channels_per_group */,
1685 672 /* input pixel stride */,
1686 672 /* output pixel stride */,
1687 w198, w199,
1688 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1689 0 /* flags */,
1690 &op69);
1691 if (status != xnn_status_success) {
1692 std::cerr << "failed to create operation #69" << std::endl;
1693 return ExecutionPlan();
1694 }
1695 operators.emplace_back(op69, xnn_delete_operator);
1696
1697 xnn_operator_t op70 = nullptr;
1698 status = xnn_create_hardswish_nc_f32(
1699 672 /* channels */,
1700 672 /* input stride */,
1701 672 /* output stride */,
1702 0 /* flags */,
1703 &op70);
1704 if (status != xnn_status_success) {
1705 std::cerr << "failed to create operation #70" << std::endl;
1706 return ExecutionPlan();
1707 }
1708 operators.emplace_back(op70, xnn_delete_operator);
1709
1710 xnn_operator_t op71 = nullptr;
1711 status = xnn_create_global_average_pooling_nwc_f32(
1712 672 /* channels */, 672 /* input stride */, 672 /* output stride */,
1713 -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
1714 0 /* flags */,
1715 &op71);
1716 if (status != xnn_status_success) {
1717 std::cerr << "failed to create operation #71" << std::endl;
1718 return ExecutionPlan();
1719 }
1720 operators.emplace_back(op71, xnn_delete_operator);
1721
1722 xnn_operator_t op72 = nullptr;
1723 status = xnn_create_convolution2d_nhwc_f32(
1724 0 /* top padding */, 0 /* right padding */,
1725 0 /* bottom padding */, 0 /* left padding */,
1726 1 /* kernel height */, 1 /* kernel width */,
1727 1 /* subsampling height */, 1 /* subsampling width */,
1728 1 /* dilation_height */, 1 /* dilation_width */,
1729 1 /* groups */,
1730 672 /* input channels per group */,
1731 168 /* output_channels_per_group */,
1732 672 /* input pixel stride */,
1733 168 /* output pixel stride */,
1734 w200, w201,
1735 0.0f /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1736 0 /* flags */,
1737 &op72);
1738 if (status != xnn_status_success) {
1739 std::cerr << "failed to create operation #72" << std::endl;
1740 return ExecutionPlan();
1741 }
1742 operators.emplace_back(op72, xnn_delete_operator);
1743
1744 xnn_operator_t op73 = nullptr;
1745 status = xnn_create_convolution2d_nhwc_f32(
1746 0 /* top padding */, 0 /* right padding */,
1747 0 /* bottom padding */, 0 /* left padding */,
1748 1 /* kernel height */, 1 /* kernel width */,
1749 1 /* subsampling height */, 1 /* subsampling width */,
1750 1 /* dilation_height */, 1 /* dilation_width */,
1751 1 /* groups */,
1752 168 /* input channels per group */,
1753 672 /* output_channels_per_group */,
1754 168 /* input pixel stride */,
1755 672 /* output pixel stride */,
1756 w202, w203,
1757 0.0f /* output min */, +0x1.00014Fp+0 /* output max */,
1758 0 /* flags */,
1759 &op73);
1760 if (status != xnn_status_success) {
1761 std::cerr << "failed to create operation #73" << std::endl;
1762 return ExecutionPlan();
1763 }
1764 operators.emplace_back(op73, xnn_delete_operator);
1765
1766 xnn_operator_t op74 = nullptr;
1767 status = xnn_create_multiply_nd_f32(
1768 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1769 0 /* flags */,
1770 &op74);
1771 if (status != xnn_status_success) {
1772 std::cerr << "failed to create operation #74" << std::endl;
1773 return ExecutionPlan();
1774 }
1775 operators.emplace_back(op74, xnn_delete_operator);
1776
1777 xnn_operator_t op75 = nullptr;
1778 status = xnn_create_convolution2d_nhwc_f32(
1779 0 /* top padding */, 0 /* right padding */,
1780 0 /* bottom padding */, 0 /* left padding */,
1781 1 /* kernel height */, 1 /* kernel width */,
1782 1 /* subsampling height */, 1 /* subsampling width */,
1783 1 /* dilation_height */, 1 /* dilation_width */,
1784 1 /* groups */,
1785 672 /* input channels per group */,
1786 112 /* output_channels_per_group */,
1787 672 /* input pixel stride */,
1788 112 /* output pixel stride */,
1789 w204, w205,
1790 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1791 0 /* flags */,
1792 &op75);
1793 if (status != xnn_status_success) {
1794 std::cerr << "failed to create operation #75" << std::endl;
1795 return ExecutionPlan();
1796 }
1797 operators.emplace_back(op75, xnn_delete_operator);
1798
1799 xnn_operator_t op76 = nullptr;
1800 status = xnn_create_add_nc_f32(
1801 112 /* channels */,
1802 112 /* a stride */,
1803 112 /* b stride */,
1804 112 /* c stride */,
1805 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1806 0 /* flags */,
1807 &op76);
1808 if (status != xnn_status_success) {
1809 std::cerr << "failed to create operation #76" << std::endl;
1810 return ExecutionPlan();
1811 }
1812 operators.emplace_back(op76, xnn_delete_operator);
1813
1814 xnn_operator_t op77 = nullptr;
1815 status = xnn_create_convolution2d_nhwc_f32(
1816 0 /* top padding */, 0 /* right padding */,
1817 0 /* bottom padding */, 0 /* left padding */,
1818 1 /* kernel height */, 1 /* kernel width */,
1819 1 /* subsampling height */, 1 /* subsampling width */,
1820 1 /* dilation_height */, 1 /* dilation_width */,
1821 1 /* groups */,
1822 112 /* input channels per group */,
1823 672 /* output_channels_per_group */,
1824 112 /* input pixel stride */,
1825 672 /* output pixel stride */,
1826 w206, w207,
1827 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1828 0 /* flags */,
1829 &op77);
1830 if (status != xnn_status_success) {
1831 std::cerr << "failed to create operation #77" << std::endl;
1832 return ExecutionPlan();
1833 }
1834 operators.emplace_back(op77, xnn_delete_operator);
1835
1836 xnn_operator_t op78 = nullptr;
1837 status = xnn_create_hardswish_nc_f32(
1838 672 /* channels */,
1839 672 /* input stride */,
1840 672 /* output stride */,
1841 0 /* flags */,
1842 &op78);
1843 if (status != xnn_status_success) {
1844 std::cerr << "failed to create operation #78" << std::endl;
1845 return ExecutionPlan();
1846 }
1847 operators.emplace_back(op78, xnn_delete_operator);
1848
1849 xnn_operator_t op79 = nullptr;
1850 status = xnn_create_convolution2d_nhwc_f32(
1851 1 /* top padding */, 2 /* right padding */,
1852 2 /* bottom padding */, 1 /* left padding */,
1853 5 /* kernel height */, 5 /* kernel width */,
1854 2 /* subsampling height */, 2 /* subsampling width */,
1855 1 /* dilation_height */, 1 /* dilation_width */,
1856 672 /* groups */,
1857 1 /* input channels per group */,
1858 1 /* output_channels_per_group */,
1859 672 /* input pixel stride */,
1860 672 /* output pixel stride */,
1861 w208, w209,
1862 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1863 0 /* flags */,
1864 &op79);
1865 if (status != xnn_status_success) {
1866 std::cerr << "failed to create operation #79" << std::endl;
1867 return ExecutionPlan();
1868 }
1869 operators.emplace_back(op79, xnn_delete_operator);
1870
1871 xnn_operator_t op80 = nullptr;
1872 status = xnn_create_hardswish_nc_f32(
1873 672 /* channels */,
1874 672 /* input stride */,
1875 672 /* output stride */,
1876 0 /* flags */,
1877 &op80);
1878 if (status != xnn_status_success) {
1879 std::cerr << "failed to create operation #80" << std::endl;
1880 return ExecutionPlan();
1881 }
1882 operators.emplace_back(op80, xnn_delete_operator);
1883
1884 xnn_operator_t op81 = nullptr;
1885 status = xnn_create_global_average_pooling_nwc_f32(
1886 672 /* channels */, 672 /* input stride */, 672 /* output stride */,
1887 -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
1888 0 /* flags */,
1889 &op81);
1890 if (status != xnn_status_success) {
1891 std::cerr << "failed to create operation #81" << std::endl;
1892 return ExecutionPlan();
1893 }
1894 operators.emplace_back(op81, xnn_delete_operator);
1895
1896 xnn_operator_t op82 = nullptr;
1897 status = xnn_create_convolution2d_nhwc_f32(
1898 0 /* top padding */, 0 /* right padding */,
1899 0 /* bottom padding */, 0 /* left padding */,
1900 1 /* kernel height */, 1 /* kernel width */,
1901 1 /* subsampling height */, 1 /* subsampling width */,
1902 1 /* dilation_height */, 1 /* dilation_width */,
1903 1 /* groups */,
1904 672 /* input channels per group */,
1905 168 /* output_channels_per_group */,
1906 672 /* input pixel stride */,
1907 168 /* output pixel stride */,
1908 w210, w211,
1909 0.0f /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1910 0 /* flags */,
1911 &op82);
1912 if (status != xnn_status_success) {
1913 std::cerr << "failed to create operation #82" << std::endl;
1914 return ExecutionPlan();
1915 }
1916 operators.emplace_back(op82, xnn_delete_operator);
1917
1918 xnn_operator_t op83 = nullptr;
1919 status = xnn_create_convolution2d_nhwc_f32(
1920 0 /* top padding */, 0 /* right padding */,
1921 0 /* bottom padding */, 0 /* left padding */,
1922 1 /* kernel height */, 1 /* kernel width */,
1923 1 /* subsampling height */, 1 /* subsampling width */,
1924 1 /* dilation_height */, 1 /* dilation_width */,
1925 1 /* groups */,
1926 168 /* input channels per group */,
1927 672 /* output_channels_per_group */,
1928 168 /* input pixel stride */,
1929 672 /* output pixel stride */,
1930 w212, w213,
1931 0.0f /* output min */, +0x1.00014Fp+0 /* output max */,
1932 0 /* flags */,
1933 &op83);
1934 if (status != xnn_status_success) {
1935 std::cerr << "failed to create operation #83" << std::endl;
1936 return ExecutionPlan();
1937 }
1938 operators.emplace_back(op83, xnn_delete_operator);
1939
1940 xnn_operator_t op84 = nullptr;
1941 status = xnn_create_multiply_nd_f32(
1942 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1943 0 /* flags */,
1944 &op84);
1945 if (status != xnn_status_success) {
1946 std::cerr << "failed to create operation #84" << std::endl;
1947 return ExecutionPlan();
1948 }
1949 operators.emplace_back(op84, xnn_delete_operator);
1950
1951 xnn_operator_t op85 = nullptr;
1952 status = xnn_create_convolution2d_nhwc_f32(
1953 0 /* top padding */, 0 /* right padding */,
1954 0 /* bottom padding */, 0 /* left padding */,
1955 1 /* kernel height */, 1 /* kernel width */,
1956 1 /* subsampling height */, 1 /* subsampling width */,
1957 1 /* dilation_height */, 1 /* dilation_width */,
1958 1 /* groups */,
1959 672 /* input channels per group */,
1960 160 /* output_channels_per_group */,
1961 672 /* input pixel stride */,
1962 160 /* output pixel stride */,
1963 w214, w215,
1964 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1965 0 /* flags */,
1966 &op85);
1967 if (status != xnn_status_success) {
1968 std::cerr << "failed to create operation #85" << std::endl;
1969 return ExecutionPlan();
1970 }
1971 operators.emplace_back(op85, xnn_delete_operator);
1972
1973 xnn_operator_t op86 = nullptr;
1974 status = xnn_create_convolution2d_nhwc_f32(
1975 0 /* top padding */, 0 /* right padding */,
1976 0 /* bottom padding */, 0 /* left padding */,
1977 1 /* kernel height */, 1 /* kernel width */,
1978 1 /* subsampling height */, 1 /* subsampling width */,
1979 1 /* dilation_height */, 1 /* dilation_width */,
1980 1 /* groups */,
1981 160 /* input channels per group */,
1982 960 /* output_channels_per_group */,
1983 160 /* input pixel stride */,
1984 960 /* output pixel stride */,
1985 w216, w217,
1986 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1987 0 /* flags */,
1988 &op86);
1989 if (status != xnn_status_success) {
1990 std::cerr << "failed to create operation #86" << std::endl;
1991 return ExecutionPlan();
1992 }
1993 operators.emplace_back(op86, xnn_delete_operator);
1994
1995 xnn_operator_t op87 = nullptr;
1996 status = xnn_create_hardswish_nc_f32(
1997 960 /* channels */,
1998 960 /* input stride */,
1999 960 /* output stride */,
2000 0 /* flags */,
2001 &op87);
2002 if (status != xnn_status_success) {
2003 std::cerr << "failed to create operation #87" << std::endl;
2004 return ExecutionPlan();
2005 }
2006 operators.emplace_back(op87, xnn_delete_operator);
2007
2008 xnn_operator_t op88 = nullptr;
2009 status = xnn_create_convolution2d_nhwc_f32(
2010 2 /* top padding */, 2 /* right padding */,
2011 2 /* bottom padding */, 2 /* left padding */,
2012 5 /* kernel height */, 5 /* kernel width */,
2013 1 /* subsampling height */, 1 /* subsampling width */,
2014 1 /* dilation_height */, 1 /* dilation_width */,
2015 960 /* groups */,
2016 1 /* input channels per group */,
2017 1 /* output_channels_per_group */,
2018 960 /* input pixel stride */,
2019 960 /* output pixel stride */,
2020 w218, w219,
2021 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
2022 0 /* flags */,
2023 &op88);
2024 if (status != xnn_status_success) {
2025 std::cerr << "failed to create operation #88" << std::endl;
2026 return ExecutionPlan();
2027 }
2028 operators.emplace_back(op88, xnn_delete_operator);
2029
2030 xnn_operator_t op89 = nullptr;
2031 status = xnn_create_hardswish_nc_f32(
2032 960 /* channels */,
2033 960 /* input stride */,
2034 960 /* output stride */,
2035 0 /* flags */,
2036 &op89);
2037 if (status != xnn_status_success) {
2038 std::cerr << "failed to create operation #89" << std::endl;
2039 return ExecutionPlan();
2040 }
2041 operators.emplace_back(op89, xnn_delete_operator);
2042
2043 xnn_operator_t op90 = nullptr;
2044 status = xnn_create_global_average_pooling_nwc_f32(
2045 960 /* channels */, 960 /* input stride */, 960 /* output stride */,
2046 -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
2047 0 /* flags */,
2048 &op90);
2049 if (status != xnn_status_success) {
2050 std::cerr << "failed to create operation #90" << std::endl;
2051 return ExecutionPlan();
2052 }
2053 operators.emplace_back(op90, xnn_delete_operator);
2054
2055 xnn_operator_t op91 = nullptr;
2056 status = xnn_create_convolution2d_nhwc_f32(
2057 0 /* top padding */, 0 /* right padding */,
2058 0 /* bottom padding */, 0 /* left padding */,
2059 1 /* kernel height */, 1 /* kernel width */,
2060 1 /* subsampling height */, 1 /* subsampling width */,
2061 1 /* dilation_height */, 1 /* dilation_width */,
2062 1 /* groups */,
2063 960 /* input channels per group */,
2064 240 /* output_channels_per_group */,
2065 960 /* input pixel stride */,
2066 240 /* output pixel stride */,
2067 w220, w221,
2068 0.0f /* output min */, std::numeric_limits<float>::infinity() /* output max */,
2069 0 /* flags */,
2070 &op91);
2071 if (status != xnn_status_success) {
2072 std::cerr << "failed to create operation #91" << std::endl;
2073 return ExecutionPlan();
2074 }
2075 operators.emplace_back(op91, xnn_delete_operator);
2076
2077 xnn_operator_t op92 = nullptr;
2078 status = xnn_create_convolution2d_nhwc_f32(
2079 0 /* top padding */, 0 /* right padding */,
2080 0 /* bottom padding */, 0 /* left padding */,
2081 1 /* kernel height */, 1 /* kernel width */,
2082 1 /* subsampling height */, 1 /* subsampling width */,
2083 1 /* dilation_height */, 1 /* dilation_width */,
2084 1 /* groups */,
2085 240 /* input channels per group */,
2086 960 /* output_channels_per_group */,
2087 240 /* input pixel stride */,
2088 960 /* output pixel stride */,
2089 w222, w223,
2090 0.0f /* output min */, +0x1.00014Fp+0 /* output max */,
2091 0 /* flags */,
2092 &op92);
2093 if (status != xnn_status_success) {
2094 std::cerr << "failed to create operation #92" << std::endl;
2095 return ExecutionPlan();
2096 }
2097 operators.emplace_back(op92, xnn_delete_operator);
2098
2099 xnn_operator_t op93 = nullptr;
2100 status = xnn_create_multiply_nd_f32(
2101 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
2102 0 /* flags */,
2103 &op93);
2104 if (status != xnn_status_success) {
2105 std::cerr << "failed to create operation #93" << std::endl;
2106 return ExecutionPlan();
2107 }
2108 operators.emplace_back(op93, xnn_delete_operator);
2109
2110 xnn_operator_t op94 = nullptr;
2111 status = xnn_create_convolution2d_nhwc_f32(
2112 0 /* top padding */, 0 /* right padding */,
2113 0 /* bottom padding */, 0 /* left padding */,
2114 1 /* kernel height */, 1 /* kernel width */,
2115 1 /* subsampling height */, 1 /* subsampling width */,
2116 1 /* dilation_height */, 1 /* dilation_width */,
2117 1 /* groups */,
2118 960 /* input channels per group */,
2119 160 /* output_channels_per_group */,
2120 960 /* input pixel stride */,
2121 160 /* output pixel stride */,
2122 w224, w225,
2123 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
2124 0 /* flags */,
2125 &op94);
2126 if (status != xnn_status_success) {
2127 std::cerr << "failed to create operation #94" << std::endl;
2128 return ExecutionPlan();
2129 }
2130 operators.emplace_back(op94, xnn_delete_operator);
2131
2132 xnn_operator_t op95 = nullptr;
2133 status = xnn_create_add_nc_f32(
2134 160 /* channels */,
2135 160 /* a stride */,
2136 160 /* b stride */,
2137 160 /* c stride */,
2138 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
2139 0 /* flags */,
2140 &op95);
2141 if (status != xnn_status_success) {
2142 std::cerr << "failed to create operation #95" << std::endl;
2143 return ExecutionPlan();
2144 }
2145 operators.emplace_back(op95, xnn_delete_operator);
2146
2147 xnn_operator_t op96 = nullptr;
2148 status = xnn_create_convolution2d_nhwc_f32(
2149 0 /* top padding */, 0 /* right padding */,
2150 0 /* bottom padding */, 0 /* left padding */,
2151 1 /* kernel height */, 1 /* kernel width */,
2152 1 /* subsampling height */, 1 /* subsampling width */,
2153 1 /* dilation_height */, 1 /* dilation_width */,
2154 1 /* groups */,
2155 160 /* input channels per group */,
2156 960 /* output_channels_per_group */,
2157 160 /* input pixel stride */,
2158 960 /* output pixel stride */,
2159 w226, w227,
2160 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
2161 0 /* flags */,
2162 &op96);
2163 if (status != xnn_status_success) {
2164 std::cerr << "failed to create operation #96" << std::endl;
2165 return ExecutionPlan();
2166 }
2167 operators.emplace_back(op96, xnn_delete_operator);
2168
2169 xnn_operator_t op97 = nullptr;
2170 status = xnn_create_hardswish_nc_f32(
2171 960 /* channels */,
2172 960 /* input stride */,
2173 960 /* output stride */,
2174 0 /* flags */,
2175 &op97);
2176 if (status != xnn_status_success) {
2177 std::cerr << "failed to create operation #97" << std::endl;
2178 return ExecutionPlan();
2179 }
2180 operators.emplace_back(op97, xnn_delete_operator);
2181
2182 xnn_operator_t op98 = nullptr;
2183 status = xnn_create_convolution2d_nhwc_f32(
2184 2 /* top padding */, 2 /* right padding */,
2185 2 /* bottom padding */, 2 /* left padding */,
2186 5 /* kernel height */, 5 /* kernel width */,
2187 1 /* subsampling height */, 1 /* subsampling width */,
2188 1 /* dilation_height */, 1 /* dilation_width */,
2189 960 /* groups */,
2190 1 /* input channels per group */,
2191 1 /* output_channels_per_group */,
2192 960 /* input pixel stride */,
2193 960 /* output pixel stride */,
2194 w228, w229,
2195 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
2196 0 /* flags */,
2197 &op98);
2198 if (status != xnn_status_success) {
2199 std::cerr << "failed to create operation #98" << std::endl;
2200 return ExecutionPlan();
2201 }
2202 operators.emplace_back(op98, xnn_delete_operator);
2203
2204 xnn_operator_t op99 = nullptr;
2205 status = xnn_create_hardswish_nc_f32(
2206 960 /* channels */,
2207 960 /* input stride */,
2208 960 /* output stride */,
2209 0 /* flags */,
2210 &op99);
2211 if (status != xnn_status_success) {
2212 std::cerr << "failed to create operation #99" << std::endl;
2213 return ExecutionPlan();
2214 }
2215 operators.emplace_back(op99, xnn_delete_operator);
2216
2217 xnn_operator_t op100 = nullptr;
2218 status = xnn_create_global_average_pooling_nwc_f32(
2219 960 /* channels */, 960 /* input stride */, 960 /* output stride */,
2220 -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
2221 0 /* flags */,
2222 &op100);
2223 if (status != xnn_status_success) {
2224 std::cerr << "failed to create operation #100" << std::endl;
2225 return ExecutionPlan();
2226 }
2227 operators.emplace_back(op100, xnn_delete_operator);
2228
2229 xnn_operator_t op101 = nullptr;
2230 status = xnn_create_convolution2d_nhwc_f32(
2231 0 /* top padding */, 0 /* right padding */,
2232 0 /* bottom padding */, 0 /* left padding */,
2233 1 /* kernel height */, 1 /* kernel width */,
2234 1 /* subsampling height */, 1 /* subsampling width */,
2235 1 /* dilation_height */, 1 /* dilation_width */,
2236 1 /* groups */,
2237 960 /* input channels per group */,
2238 240 /* output_channels_per_group */,
2239 960 /* input pixel stride */,
2240 240 /* output pixel stride */,
2241 w230, w231,
2242 0.0f /* output min */, std::numeric_limits<float>::infinity() /* output max */,
2243 0 /* flags */,
2244 &op101);
2245 if (status != xnn_status_success) {
2246 std::cerr << "failed to create operation #101" << std::endl;
2247 return ExecutionPlan();
2248 }
2249 operators.emplace_back(op101, xnn_delete_operator);
2250
2251 xnn_operator_t op102 = nullptr;
2252 status = xnn_create_convolution2d_nhwc_f32(
2253 0 /* top padding */, 0 /* right padding */,
2254 0 /* bottom padding */, 0 /* left padding */,
2255 1 /* kernel height */, 1 /* kernel width */,
2256 1 /* subsampling height */, 1 /* subsampling width */,
2257 1 /* dilation_height */, 1 /* dilation_width */,
2258 1 /* groups */,
2259 240 /* input channels per group */,
2260 960 /* output_channels_per_group */,
2261 240 /* input pixel stride */,
2262 960 /* output pixel stride */,
2263 w232, w233,
2264 0.0f /* output min */, +0x1.00014Fp+0 /* output max */,
2265 0 /* flags */,
2266 &op102);
2267 if (status != xnn_status_success) {
2268 std::cerr << "failed to create operation #102" << std::endl;
2269 return ExecutionPlan();
2270 }
2271 operators.emplace_back(op102, xnn_delete_operator);
2272
2273 xnn_operator_t op103 = nullptr;
2274 status = xnn_create_multiply_nd_f32(
2275 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
2276 0 /* flags */,
2277 &op103);
2278 if (status != xnn_status_success) {
2279 std::cerr << "failed to create operation #103" << std::endl;
2280 return ExecutionPlan();
2281 }
2282 operators.emplace_back(op103, xnn_delete_operator);
2283
2284 xnn_operator_t op104 = nullptr;
2285 status = xnn_create_convolution2d_nhwc_f32(
2286 0 /* top padding */, 0 /* right padding */,
2287 0 /* bottom padding */, 0 /* left padding */,
2288 1 /* kernel height */, 1 /* kernel width */,
2289 1 /* subsampling height */, 1 /* subsampling width */,
2290 1 /* dilation_height */, 1 /* dilation_width */,
2291 1 /* groups */,
2292 960 /* input channels per group */,
2293 160 /* output_channels_per_group */,
2294 960 /* input pixel stride */,
2295 160 /* output pixel stride */,
2296 w234, w235,
2297 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
2298 0 /* flags */,
2299 &op104);
2300 if (status != xnn_status_success) {
2301 std::cerr << "failed to create operation #104" << std::endl;
2302 return ExecutionPlan();
2303 }
2304 operators.emplace_back(op104, xnn_delete_operator);
2305
2306 xnn_operator_t op105 = nullptr;
2307 status = xnn_create_add_nc_f32(
2308 160 /* channels */,
2309 160 /* a stride */,
2310 160 /* b stride */,
2311 160 /* c stride */,
2312 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
2313 0 /* flags */,
2314 &op105);
2315 if (status != xnn_status_success) {
2316 std::cerr << "failed to create operation #105" << std::endl;
2317 return ExecutionPlan();
2318 }
2319 operators.emplace_back(op105, xnn_delete_operator);
2320
2321 xnn_operator_t op106 = nullptr;
2322 status = xnn_create_convolution2d_nhwc_f32(
2323 0 /* top padding */, 0 /* right padding */,
2324 0 /* bottom padding */, 0 /* left padding */,
2325 1 /* kernel height */, 1 /* kernel width */,
2326 1 /* subsampling height */, 1 /* subsampling width */,
2327 1 /* dilation_height */, 1 /* dilation_width */,
2328 1 /* groups */,
2329 160 /* input channels per group */,
2330 960 /* output_channels_per_group */,
2331 160 /* input pixel stride */,
2332 960 /* output pixel stride */,
2333 w236, w237,
2334 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
2335 0 /* flags */,
2336 &op106);
2337 if (status != xnn_status_success) {
2338 std::cerr << "failed to create operation #106" << std::endl;
2339 return ExecutionPlan();
2340 }
2341 operators.emplace_back(op106, xnn_delete_operator);
2342
2343 xnn_operator_t op107 = nullptr;
2344 status = xnn_create_hardswish_nc_f32(
2345 960 /* channels */,
2346 960 /* input stride */,
2347 960 /* output stride */,
2348 0 /* flags */,
2349 &op107);
2350 if (status != xnn_status_success) {
2351 std::cerr << "failed to create operation #107" << std::endl;
2352 return ExecutionPlan();
2353 }
2354 operators.emplace_back(op107, xnn_delete_operator);
2355
2356 xnn_operator_t op108 = nullptr;
2357 status = xnn_create_global_average_pooling_nwc_f32(
2358 960 /* channels */, 960 /* input stride */, 960 /* output stride */,
2359 -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
2360 0 /* flags */,
2361 &op108);
2362 if (status != xnn_status_success) {
2363 std::cerr << "failed to create operation #108" << std::endl;
2364 return ExecutionPlan();
2365 }
2366 operators.emplace_back(op108, xnn_delete_operator);
2367
2368 xnn_operator_t op109 = nullptr;
2369 status = xnn_create_convolution2d_nhwc_f32(
2370 0 /* top padding */, 0 /* right padding */,
2371 0 /* bottom padding */, 0 /* left padding */,
2372 1 /* kernel height */, 1 /* kernel width */,
2373 1 /* subsampling height */, 1 /* subsampling width */,
2374 1 /* dilation_height */, 1 /* dilation_width */,
2375 1 /* groups */,
2376 960 /* input channels per group */,
2377 1280 /* output_channels_per_group */,
2378 960 /* input pixel stride */,
2379 1280 /* output pixel stride */,
2380 w238, w239,
2381 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
2382 0 /* flags */,
2383 &op109);
2384 if (status != xnn_status_success) {
2385 std::cerr << "failed to create operation #109" << std::endl;
2386 return ExecutionPlan();
2387 }
2388 operators.emplace_back(op109, xnn_delete_operator);
2389
2390 xnn_operator_t op110 = nullptr;
2391 status = xnn_create_hardswish_nc_f32(
2392 1280 /* channels */,
2393 1280 /* input stride */,
2394 1280 /* output stride */,
2395 0 /* flags */,
2396 &op110);
2397 if (status != xnn_status_success) {
2398 std::cerr << "failed to create operation #110" << std::endl;
2399 return ExecutionPlan();
2400 }
2401 operators.emplace_back(op110, xnn_delete_operator);
2402
2403 xnn_operator_t op111 = nullptr;
2404 status = xnn_create_global_average_pooling_nwc_f32(
2405 1280 /* channels */, 1280 /* input stride */, 1280 /* output stride */,
2406 -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
2407 0 /* flags */,
2408 &op111);
2409 if (status != xnn_status_success) {
2410 std::cerr << "failed to create operation #111" << std::endl;
2411 return ExecutionPlan();
2412 }
2413 operators.emplace_back(op111, xnn_delete_operator);
2414
2415 xnn_operator_t op112 = nullptr;
2416 status = xnn_create_convolution2d_nhwc_f32(
2417 0 /* top padding */, 0 /* right padding */,
2418 0 /* bottom padding */, 0 /* left padding */,
2419 1 /* kernel height */, 1 /* kernel width */,
2420 1 /* subsampling height */, 1 /* subsampling width */,
2421 1 /* dilation_height */, 1 /* dilation_width */,
2422 1 /* groups */,
2423 1280 /* input channels per group */,
2424 1001 /* output_channels_per_group */,
2425 1280 /* input pixel stride */,
2426 1001 /* output pixel stride */,
2427 w240, w241,
2428 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
2429 0 /* flags */,
2430 &op112);
2431 if (status != xnn_status_success) {
2432 std::cerr << "failed to create operation #112" << std::endl;
2433 return ExecutionPlan();
2434 }
2435 operators.emplace_back(op112, xnn_delete_operator);
2436
2437
2438
2439 status = xnn_setup_convolution2d_nhwc_f32(
2440 op0,
2441 1 /* batch size */, 224 /* input height */, 224 /* input width */,
2442 &v0[0] /* input */, &v1[0] /* output */,
2443 threadpool /* threadpool */);
2444 if (status != xnn_status_success) {
2445 std::cerr << "failed to setup operation #0" << std::endl;
2446 return ExecutionPlan();
2447 }
2448
2449 status = xnn_setup_hardswish_nc_f32(
2450 op1,
2451 12544 /* batch size */,
2452 &v1[0] /* input */, &v2[0] /* output */,
2453 threadpool /* threadpool */);
2454 if (status != xnn_status_success) {
2455 std::cerr << "failed to setup operation #1" << std::endl;
2456 return ExecutionPlan();
2457 }
2458
2459 status = xnn_setup_convolution2d_nhwc_f32(
2460 op2,
2461 1 /* batch size */, 112 /* input height */, 112 /* input width */,
2462 &v2[0] /* input */, &v3[0] /* output */,
2463 threadpool /* threadpool */);
2464 if (status != xnn_status_success) {
2465 std::cerr << "failed to setup operation #2" << std::endl;
2466 return ExecutionPlan();
2467 }
2468
2469 status = xnn_setup_convolution2d_nhwc_f32(
2470 op3,
2471 1 /* batch size */, 112 /* input height */, 112 /* input width */,
2472 &v3[0] /* input */, &v4[0] /* output */,
2473 threadpool /* threadpool */);
2474 if (status != xnn_status_success) {
2475 std::cerr << "failed to setup operation #3" << std::endl;
2476 return ExecutionPlan();
2477 }
2478
2479 status = xnn_setup_add_nc_f32(
2480 op4,
2481 12544 /* batch size */,
2482 &v4[0] /* a */, &v2[0] /* b */, &v5[0] /* sum */,
2483 threadpool /* threadpool */);
2484 if (status != xnn_status_success) {
2485 std::cerr << "failed to setup operation #4" << std::endl;
2486 return ExecutionPlan();
2487 }
2488
2489 status = xnn_setup_convolution2d_nhwc_f32(
2490 op5,
2491 1 /* batch size */, 112 /* input height */, 112 /* input width */,
2492 &v5[0] /* input */, &v6[0] /* output */,
2493 threadpool /* threadpool */);
2494 if (status != xnn_status_success) {
2495 std::cerr << "failed to setup operation #5" << std::endl;
2496 return ExecutionPlan();
2497 }
2498
2499 status = xnn_setup_convolution2d_nhwc_f32(
2500 op6,
2501 1 /* batch size */, 112 /* input height */, 112 /* input width */,
2502 &v6[0] /* input */, &v7[0] /* output */,
2503 threadpool /* threadpool */);
2504 if (status != xnn_status_success) {
2505 std::cerr << "failed to setup operation #6" << std::endl;
2506 return ExecutionPlan();
2507 }
2508
2509 status = xnn_setup_convolution2d_nhwc_f32(
2510 op7,
2511 1 /* batch size */, 56 /* input height */, 56 /* input width */,
2512 &v7[0] /* input */, &v8[0] /* output */,
2513 threadpool /* threadpool */);
2514 if (status != xnn_status_success) {
2515 std::cerr << "failed to setup operation #7" << std::endl;
2516 return ExecutionPlan();
2517 }
2518
2519 status = xnn_setup_convolution2d_nhwc_f32(
2520 op8,
2521 1 /* batch size */, 56 /* input height */, 56 /* input width */,
2522 &v8[0] /* input */, &v9[0] /* output */,
2523 threadpool /* threadpool */);
2524 if (status != xnn_status_success) {
2525 std::cerr << "failed to setup operation #8" << std::endl;
2526 return ExecutionPlan();
2527 }
2528
2529 status = xnn_setup_convolution2d_nhwc_f32(
2530 op9,
2531 1 /* batch size */, 56 /* input height */, 56 /* input width */,
2532 &v9[0] /* input */, &v10[0] /* output */,
2533 threadpool /* threadpool */);
2534 if (status != xnn_status_success) {
2535 std::cerr << "failed to setup operation #9" << std::endl;
2536 return ExecutionPlan();
2537 }
2538
2539 status = xnn_setup_convolution2d_nhwc_f32(
2540 op10,
2541 1 /* batch size */, 56 /* input height */, 56 /* input width */,
2542 &v10[0] /* input */, &v11[0] /* output */,
2543 threadpool /* threadpool */);
2544 if (status != xnn_status_success) {
2545 std::cerr << "failed to setup operation #10" << std::endl;
2546 return ExecutionPlan();
2547 }
2548
2549 status = xnn_setup_add_nc_f32(
2550 op11,
2551 3136 /* batch size */,
2552 &v11[0] /* a */, &v8[0] /* b */, &v12[0] /* sum */,
2553 threadpool /* threadpool */);
2554 if (status != xnn_status_success) {
2555 std::cerr << "failed to setup operation #11" << std::endl;
2556 return ExecutionPlan();
2557 }
2558
2559 status = xnn_setup_convolution2d_nhwc_f32(
2560 op12,
2561 1 /* batch size */, 56 /* input height */, 56 /* input width */,
2562 &v12[0] /* input */, &v13[0] /* output */,
2563 threadpool /* threadpool */);
2564 if (status != xnn_status_success) {
2565 std::cerr << "failed to setup operation #12" << std::endl;
2566 return ExecutionPlan();
2567 }
2568
2569 status = xnn_setup_convolution2d_nhwc_f32(
2570 op13,
2571 1 /* batch size */, 56 /* input height */, 56 /* input width */,
2572 &v13[0] /* input */, &v14[0] /* output */,
2573 threadpool /* threadpool */);
2574 if (status != xnn_status_success) {
2575 std::cerr << "failed to setup operation #13" << std::endl;
2576 return ExecutionPlan();
2577 }
2578
2579 status = xnn_setup_global_average_pooling_nwc_f32(
2580 op14,
2581 1 /* batch size */, 784 /* width */,
2582 &v14[0] /* input */, &v15[0] /* output */,
2583 threadpool /* threadpool */);
2584 if (status != xnn_status_success) {
2585 std::cerr << "failed to setup operation #14" << std::endl;
2586 return ExecutionPlan();
2587 }
2588
2589 status = xnn_setup_convolution2d_nhwc_f32(
2590 op15,
2591 1 /* batch size */, 1 /* input height */, 1 /* input width */,
2592 &v15[0] /* input */, &v16[0] /* output */,
2593 threadpool /* threadpool */);
2594 if (status != xnn_status_success) {
2595 std::cerr << "failed to setup operation #15" << std::endl;
2596 return ExecutionPlan();
2597 }
2598
2599 status = xnn_setup_convolution2d_nhwc_f32(
2600 op16,
2601 1 /* batch size */, 1 /* input height */, 1 /* input width */,
2602 &v16[0] /* input */, &v17[0] /* output */,
2603 threadpool /* threadpool */);
2604 if (status != xnn_status_success) {
2605 std::cerr << "failed to setup operation #16" << std::endl;
2606 return ExecutionPlan();
2607 }
2608
2609 {
2610 const size_t a_shape[] = { 1, 28, 28, 72 };
2611 const size_t b_shape[] = { 1, 1, 1, 72 };
2612 status = xnn_setup_multiply_nd_f32(
2613 op17,
2614 4, a_shape, 4, b_shape,
2615 &v14[0] /* a */, &v17[0] /* b */, &v18[0] /* output */,
2616 threadpool /* threadpool */);
2617 }
2618 if (status != xnn_status_success) {
2619 std::cerr << "failed to setup operation #17" << std::endl;
2620 return ExecutionPlan();
2621 }
2622
2623 status = xnn_setup_convolution2d_nhwc_f32(
2624 op18,
2625 1 /* batch size */, 28 /* input height */, 28 /* input width */,
2626 &v18[0] /* input */, &v19[0] /* output */,
2627 threadpool /* threadpool */);
2628 if (status != xnn_status_success) {
2629 std::cerr << "failed to setup operation #18" << std::endl;
2630 return ExecutionPlan();
2631 }
2632
2633 status = xnn_setup_convolution2d_nhwc_f32(
2634 op19,
2635 1 /* batch size */, 28 /* input height */, 28 /* input width */,
2636 &v19[0] /* input */, &v20[0] /* output */,
2637 threadpool /* threadpool */);
2638 if (status != xnn_status_success) {
2639 std::cerr << "failed to setup operation #19" << std::endl;
2640 return ExecutionPlan();
2641 }
2642
2643 status = xnn_setup_convolution2d_nhwc_f32(
2644 op20,
2645 1 /* batch size */, 28 /* input height */, 28 /* input width */,
2646 &v20[0] /* input */, &v21[0] /* output */,
2647 threadpool /* threadpool */);
2648 if (status != xnn_status_success) {
2649 std::cerr << "failed to setup operation #20" << std::endl;
2650 return ExecutionPlan();
2651 }
2652
2653 status = xnn_setup_global_average_pooling_nwc_f32(
2654 op21,
2655 1 /* batch size */, 784 /* width */,
2656 &v21[0] /* input */, &v22[0] /* output */,
2657 threadpool /* threadpool */);
2658 if (status != xnn_status_success) {
2659 std::cerr << "failed to setup operation #21" << std::endl;
2660 return ExecutionPlan();
2661 }
2662
2663 status = xnn_setup_convolution2d_nhwc_f32(
2664 op22,
2665 1 /* batch size */, 1 /* input height */, 1 /* input width */,
2666 &v22[0] /* input */, &v23[0] /* output */,
2667 threadpool /* threadpool */);
2668 if (status != xnn_status_success) {
2669 std::cerr << "failed to setup operation #22" << std::endl;
2670 return ExecutionPlan();
2671 }
2672
2673 status = xnn_setup_convolution2d_nhwc_f32(
2674 op23,
2675 1 /* batch size */, 1 /* input height */, 1 /* input width */,
2676 &v23[0] /* input */, &v24[0] /* output */,
2677 threadpool /* threadpool */);
2678 if (status != xnn_status_success) {
2679 std::cerr << "failed to setup operation #23" << std::endl;
2680 return ExecutionPlan();
2681 }
2682
2683 {
2684 const size_t a_shape[] = { 1, 28, 28, 120 };
2685 const size_t b_shape[] = { 1, 1, 1, 120 };
2686 status = xnn_setup_multiply_nd_f32(
2687 op24,
2688 4, a_shape, 4, b_shape,
2689 &v21[0] /* a */, &v24[0] /* b */, &v25[0] /* output */,
2690 threadpool /* threadpool */);
2691 }
2692 if (status != xnn_status_success) {
2693 std::cerr << "failed to setup operation #24" << std::endl;
2694 return ExecutionPlan();
2695 }
2696
2697 status = xnn_setup_convolution2d_nhwc_f32(
2698 op25,
2699 1 /* batch size */, 28 /* input height */, 28 /* input width */,
2700 &v25[0] /* input */, &v26[0] /* output */,
2701 threadpool /* threadpool */);
2702 if (status != xnn_status_success) {
2703 std::cerr << "failed to setup operation #25" << std::endl;
2704 return ExecutionPlan();
2705 }
2706
2707 status = xnn_setup_add_nc_f32(
2708 op26,
2709 784 /* batch size */,
2710 &v26[0] /* a */, &v19[0] /* b */, &v27[0] /* sum */,
2711 threadpool /* threadpool */);
2712 if (status != xnn_status_success) {
2713 std::cerr << "failed to setup operation #26" << std::endl;
2714 return ExecutionPlan();
2715 }
2716
2717 status = xnn_setup_convolution2d_nhwc_f32(
2718 op27,
2719 1 /* batch size */, 28 /* input height */, 28 /* input width */,
2720 &v27[0] /* input */, &v28[0] /* output */,
2721 threadpool /* threadpool */);
2722 if (status != xnn_status_success) {
2723 std::cerr << "failed to setup operation #27" << std::endl;
2724 return ExecutionPlan();
2725 }
2726
2727 status = xnn_setup_convolution2d_nhwc_f32(
2728 op28,
2729 1 /* batch size */, 28 /* input height */, 28 /* input width */,
2730 &v28[0] /* input */, &v29[0] /* output */,
2731 threadpool /* threadpool */);
2732 if (status != xnn_status_success) {
2733 std::cerr << "failed to setup operation #28" << std::endl;
2734 return ExecutionPlan();
2735 }
2736
2737 status = xnn_setup_global_average_pooling_nwc_f32(
2738 op29,
2739 1 /* batch size */, 784 /* width */,
2740 &v29[0] /* input */, &v30[0] /* output */,
2741 threadpool /* threadpool */);
2742 if (status != xnn_status_success) {
2743 std::cerr << "failed to setup operation #29" << std::endl;
2744 return ExecutionPlan();
2745 }
2746
2747 status = xnn_setup_convolution2d_nhwc_f32(
2748 op30,
2749 1 /* batch size */, 1 /* input height */, 1 /* input width */,
2750 &v30[0] /* input */, &v31[0] /* output */,
2751 threadpool /* threadpool */);
2752 if (status != xnn_status_success) {
2753 std::cerr << "failed to setup operation #30" << std::endl;
2754 return ExecutionPlan();
2755 }
2756
2757 status = xnn_setup_convolution2d_nhwc_f32(
2758 op31,
2759 1 /* batch size */, 1 /* input height */, 1 /* input width */,
2760 &v31[0] /* input */, &v32[0] /* output */,
2761 threadpool /* threadpool */);
2762 if (status != xnn_status_success) {
2763 std::cerr << "failed to setup operation #31" << std::endl;
2764 return ExecutionPlan();
2765 }
2766
2767 {
2768 const size_t a_shape[] = { 1, 28, 28, 120 };
2769 const size_t b_shape[] = { 1, 1, 1, 120 };
2770 status = xnn_setup_multiply_nd_f32(
2771 op32,
2772 4, a_shape, 4, b_shape,
2773 &v29[0] /* a */, &v32[0] /* b */, &v33[0] /* output */,
2774 threadpool /* threadpool */);
2775 }
2776 if (status != xnn_status_success) {
2777 std::cerr << "failed to setup operation #32" << std::endl;
2778 return ExecutionPlan();
2779 }
2780
2781 status = xnn_setup_convolution2d_nhwc_f32(
2782 op33,
2783 1 /* batch size */, 28 /* input height */, 28 /* input width */,
2784 &v33[0] /* input */, &v34[0] /* output */,
2785 threadpool /* threadpool */);
2786 if (status != xnn_status_success) {
2787 std::cerr << "failed to setup operation #33" << std::endl;
2788 return ExecutionPlan();
2789 }
2790
2791 status = xnn_setup_add_nc_f32(
2792 op34,
2793 784 /* batch size */,
2794 &v34[0] /* a */, &v27[0] /* b */, &v35[0] /* sum */,
2795 threadpool /* threadpool */);
2796 if (status != xnn_status_success) {
2797 std::cerr << "failed to setup operation #34" << std::endl;
2798 return ExecutionPlan();
2799 }
2800
2801 status = xnn_setup_convolution2d_nhwc_f32(
2802 op35,
2803 1 /* batch size */, 28 /* input height */, 28 /* input width */,
2804 &v35[0] /* input */, &v36[0] /* output */,
2805 threadpool /* threadpool */);
2806 if (status != xnn_status_success) {
2807 std::cerr << "failed to setup operation #35" << std::endl;
2808 return ExecutionPlan();
2809 }
2810
2811 status = xnn_setup_hardswish_nc_f32(
2812 op36,
2813 784 /* batch size */,
2814 &v36[0] /* input */, &v37[0] /* output */,
2815 threadpool /* threadpool */);
2816 if (status != xnn_status_success) {
2817 std::cerr << "failed to setup operation #36" << std::endl;
2818 return ExecutionPlan();
2819 }
2820
2821 status = xnn_setup_convolution2d_nhwc_f32(
2822 op37,
2823 1 /* batch size */, 28 /* input height */, 28 /* input width */,
2824 &v37[0] /* input */, &v38[0] /* output */,
2825 threadpool /* threadpool */);
2826 if (status != xnn_status_success) {
2827 std::cerr << "failed to setup operation #37" << std::endl;
2828 return ExecutionPlan();
2829 }
2830
2831 status = xnn_setup_hardswish_nc_f32(
2832 op38,
2833 196 /* batch size */,
2834 &v38[0] /* input */, &v39[0] /* output */,
2835 threadpool /* threadpool */);
2836 if (status != xnn_status_success) {
2837 std::cerr << "failed to setup operation #38" << std::endl;
2838 return ExecutionPlan();
2839 }
2840
2841 status = xnn_setup_convolution2d_nhwc_f32(
2842 op39,
2843 1 /* batch size */, 14 /* input height */, 14 /* input width */,
2844 &v39[0] /* input */, &v40[0] /* output */,
2845 threadpool /* threadpool */);
2846 if (status != xnn_status_success) {
2847 std::cerr << "failed to setup operation #39" << std::endl;
2848 return ExecutionPlan();
2849 }
2850
2851 status = xnn_setup_convolution2d_nhwc_f32(
2852 op40,
2853 1 /* batch size */, 14 /* input height */, 14 /* input width */,
2854 &v40[0] /* input */, &v41[0] /* output */,
2855 threadpool /* threadpool */);
2856 if (status != xnn_status_success) {
2857 std::cerr << "failed to setup operation #40" << std::endl;
2858 return ExecutionPlan();
2859 }
2860
2861 status = xnn_setup_hardswish_nc_f32(
2862 op41,
2863 196 /* batch size */,
2864 &v41[0] /* input */, &v42[0] /* output */,
2865 threadpool /* threadpool */);
2866 if (status != xnn_status_success) {
2867 std::cerr << "failed to setup operation #41" << std::endl;
2868 return ExecutionPlan();
2869 }
2870
2871 status = xnn_setup_convolution2d_nhwc_f32(
2872 op42,
2873 1 /* batch size */, 14 /* input height */, 14 /* input width */,
2874 &v42[0] /* input */, &v43[0] /* output */,
2875 threadpool /* threadpool */);
2876 if (status != xnn_status_success) {
2877 std::cerr << "failed to setup operation #42" << std::endl;
2878 return ExecutionPlan();
2879 }
2880
2881 status = xnn_setup_hardswish_nc_f32(
2882 op43,
2883 196 /* batch size */,
2884 &v43[0] /* input */, &v44[0] /* output */,
2885 threadpool /* threadpool */);
2886 if (status != xnn_status_success) {
2887 std::cerr << "failed to setup operation #43" << std::endl;
2888 return ExecutionPlan();
2889 }
2890
2891 status = xnn_setup_convolution2d_nhwc_f32(
2892 op44,
2893 1 /* batch size */, 14 /* input height */, 14 /* input width */,
2894 &v44[0] /* input */, &v45[0] /* output */,
2895 threadpool /* threadpool */);
2896 if (status != xnn_status_success) {
2897 std::cerr << "failed to setup operation #44" << std::endl;
2898 return ExecutionPlan();
2899 }
2900
2901 status = xnn_setup_add_nc_f32(
2902 op45,
2903 196 /* batch size */,
2904 &v45[0] /* a */, &v40[0] /* b */, &v46[0] /* sum */,
2905 threadpool /* threadpool */);
2906 if (status != xnn_status_success) {
2907 std::cerr << "failed to setup operation #45" << std::endl;
2908 return ExecutionPlan();
2909 }
2910
2911 status = xnn_setup_convolution2d_nhwc_f32(
2912 op46,
2913 1 /* batch size */, 14 /* input height */, 14 /* input width */,
2914 &v46[0] /* input */, &v47[0] /* output */,
2915 threadpool /* threadpool */);
2916 if (status != xnn_status_success) {
2917 std::cerr << "failed to setup operation #46" << std::endl;
2918 return ExecutionPlan();
2919 }
2920
2921 status = xnn_setup_hardswish_nc_f32(
2922 op47,
2923 196 /* batch size */,
2924 &v47[0] /* input */, &v48[0] /* output */,
2925 threadpool /* threadpool */);
2926 if (status != xnn_status_success) {
2927 std::cerr << "failed to setup operation #47" << std::endl;
2928 return ExecutionPlan();
2929 }
2930
2931 status = xnn_setup_convolution2d_nhwc_f32(
2932 op48,
2933 1 /* batch size */, 14 /* input height */, 14 /* input width */,
2934 &v48[0] /* input */, &v49[0] /* output */,
2935 threadpool /* threadpool */);
2936 if (status != xnn_status_success) {
2937 std::cerr << "failed to setup operation #48" << std::endl;
2938 return ExecutionPlan();
2939 }
2940
2941 status = xnn_setup_hardswish_nc_f32(
2942 op49,
2943 196 /* batch size */,
2944 &v49[0] /* input */, &v50[0] /* output */,
2945 threadpool /* threadpool */);
2946 if (status != xnn_status_success) {
2947 std::cerr << "failed to setup operation #49" << std::endl;
2948 return ExecutionPlan();
2949 }
2950
2951 status = xnn_setup_convolution2d_nhwc_f32(
2952 op50,
2953 1 /* batch size */, 14 /* input height */, 14 /* input width */,
2954 &v50[0] /* input */, &v51[0] /* output */,
2955 threadpool /* threadpool */);
2956 if (status != xnn_status_success) {
2957 std::cerr << "failed to setup operation #50" << std::endl;
2958 return ExecutionPlan();
2959 }
2960
2961 status = xnn_setup_add_nc_f32(
2962 op51,
2963 196 /* batch size */,
2964 &v51[0] /* a */, &v46[0] /* b */, &v52[0] /* sum */,
2965 threadpool /* threadpool */);
2966 if (status != xnn_status_success) {
2967 std::cerr << "failed to setup operation #51" << std::endl;
2968 return ExecutionPlan();
2969 }
2970
2971 status = xnn_setup_convolution2d_nhwc_f32(
2972 op52,
2973 1 /* batch size */, 14 /* input height */, 14 /* input width */,
2974 &v52[0] /* input */, &v53[0] /* output */,
2975 threadpool /* threadpool */);
2976 if (status != xnn_status_success) {
2977 std::cerr << "failed to setup operation #52" << std::endl;
2978 return ExecutionPlan();
2979 }
2980
2981 status = xnn_setup_hardswish_nc_f32(
2982 op53,
2983 196 /* batch size */,
2984 &v53[0] /* input */, &v54[0] /* output */,
2985 threadpool /* threadpool */);
2986 if (status != xnn_status_success) {
2987 std::cerr << "failed to setup operation #53" << std::endl;
2988 return ExecutionPlan();
2989 }
2990
2991 status = xnn_setup_convolution2d_nhwc_f32(
2992 op54,
2993 1 /* batch size */, 14 /* input height */, 14 /* input width */,
2994 &v54[0] /* input */, &v55[0] /* output */,
2995 threadpool /* threadpool */);
2996 if (status != xnn_status_success) {
2997 std::cerr << "failed to setup operation #54" << std::endl;
2998 return ExecutionPlan();
2999 }
3000
3001 status = xnn_setup_hardswish_nc_f32(
3002 op55,
3003 196 /* batch size */,
3004 &v55[0] /* input */, &v56[0] /* output */,
3005 threadpool /* threadpool */);
3006 if (status != xnn_status_success) {
3007 std::cerr << "failed to setup operation #55" << std::endl;
3008 return ExecutionPlan();
3009 }
3010
3011 status = xnn_setup_convolution2d_nhwc_f32(
3012 op56,
3013 1 /* batch size */, 14 /* input height */, 14 /* input width */,
3014 &v56[0] /* input */, &v57[0] /* output */,
3015 threadpool /* threadpool */);
3016 if (status != xnn_status_success) {
3017 std::cerr << "failed to setup operation #56" << std::endl;
3018 return ExecutionPlan();
3019 }
3020
3021 status = xnn_setup_add_nc_f32(
3022 op57,
3023 196 /* batch size */,
3024 &v57[0] /* a */, &v52[0] /* b */, &v58[0] /* sum */,
3025 threadpool /* threadpool */);
3026 if (status != xnn_status_success) {
3027 std::cerr << "failed to setup operation #57" << std::endl;
3028 return ExecutionPlan();
3029 }
3030
3031 status = xnn_setup_convolution2d_nhwc_f32(
3032 op58,
3033 1 /* batch size */, 14 /* input height */, 14 /* input width */,
3034 &v58[0] /* input */, &v59[0] /* output */,
3035 threadpool /* threadpool */);
3036 if (status != xnn_status_success) {
3037 std::cerr << "failed to setup operation #58" << std::endl;
3038 return ExecutionPlan();
3039 }
3040
3041 status = xnn_setup_hardswish_nc_f32(
3042 op59,
3043 196 /* batch size */,
3044 &v59[0] /* input */, &v60[0] /* output */,
3045 threadpool /* threadpool */);
3046 if (status != xnn_status_success) {
3047 std::cerr << "failed to setup operation #59" << std::endl;
3048 return ExecutionPlan();
3049 }
3050
3051 status = xnn_setup_convolution2d_nhwc_f32(
3052 op60,
3053 1 /* batch size */, 14 /* input height */, 14 /* input width */,
3054 &v60[0] /* input */, &v61[0] /* output */,
3055 threadpool /* threadpool */);
3056 if (status != xnn_status_success) {
3057 std::cerr << "failed to setup operation #60" << std::endl;
3058 return ExecutionPlan();
3059 }
3060
3061 status = xnn_setup_hardswish_nc_f32(
3062 op61,
3063 196 /* batch size */,
3064 &v61[0] /* input */, &v62[0] /* output */,
3065 threadpool /* threadpool */);
3066 if (status != xnn_status_success) {
3067 std::cerr << "failed to setup operation #61" << std::endl;
3068 return ExecutionPlan();
3069 }
3070
3071 status = xnn_setup_global_average_pooling_nwc_f32(
3072 op62,
3073 1 /* batch size */, 196 /* width */,
3074 &v62[0] /* input */, &v63[0] /* output */,
3075 threadpool /* threadpool */);
3076 if (status != xnn_status_success) {
3077 std::cerr << "failed to setup operation #62" << std::endl;
3078 return ExecutionPlan();
3079 }
3080
3081 status = xnn_setup_convolution2d_nhwc_f32(
3082 op63,
3083 1 /* batch size */, 1 /* input height */, 1 /* input width */,
3084 &v63[0] /* input */, &v64[0] /* output */,
3085 threadpool /* threadpool */);
3086 if (status != xnn_status_success) {
3087 std::cerr << "failed to setup operation #63" << std::endl;
3088 return ExecutionPlan();
3089 }
3090
3091 status = xnn_setup_convolution2d_nhwc_f32(
3092 op64,
3093 1 /* batch size */, 1 /* input height */, 1 /* input width */,
3094 &v64[0] /* input */, &v65[0] /* output */,
3095 threadpool /* threadpool */);
3096 if (status != xnn_status_success) {
3097 std::cerr << "failed to setup operation #64" << std::endl;
3098 return ExecutionPlan();
3099 }
3100
3101 {
3102 const size_t a_shape[] = { 1, 14, 14, 480 };
3103 const size_t b_shape[] = { 1, 1, 1, 480 };
3104 status = xnn_setup_multiply_nd_f32(
3105 op65,
3106 4, a_shape, 4, b_shape,
3107 &v62[0] /* a */, &v65[0] /* b */, &v66[0] /* output */,
3108 threadpool /* threadpool */);
3109 }
3110 if (status != xnn_status_success) {
3111 std::cerr << "failed to setup operation #65" << std::endl;
3112 return ExecutionPlan();
3113 }
3114
3115 status = xnn_setup_convolution2d_nhwc_f32(
3116 op66,
3117 1 /* batch size */, 14 /* input height */, 14 /* input width */,
3118 &v66[0] /* input */, &v67[0] /* output */,
3119 threadpool /* threadpool */);
3120 if (status != xnn_status_success) {
3121 std::cerr << "failed to setup operation #66" << std::endl;
3122 return ExecutionPlan();
3123 }
3124
3125 status = xnn_setup_convolution2d_nhwc_f32(
3126 op67,
3127 1 /* batch size */, 14 /* input height */, 14 /* input width */,
3128 &v67[0] /* input */, &v68[0] /* output */,
3129 threadpool /* threadpool */);
3130 if (status != xnn_status_success) {
3131 std::cerr << "failed to setup operation #67" << std::endl;
3132 return ExecutionPlan();
3133 }
3134
3135 status = xnn_setup_hardswish_nc_f32(
3136 op68,
3137 196 /* batch size */,
3138 &v68[0] /* input */, &v69[0] /* output */,
3139 threadpool /* threadpool */);
3140 if (status != xnn_status_success) {
3141 std::cerr << "failed to setup operation #68" << std::endl;
3142 return ExecutionPlan();
3143 }
3144
3145 status = xnn_setup_convolution2d_nhwc_f32(
3146 op69,
3147 1 /* batch size */, 14 /* input height */, 14 /* input width */,
3148 &v69[0] /* input */, &v70[0] /* output */,
3149 threadpool /* threadpool */);
3150 if (status != xnn_status_success) {
3151 std::cerr << "failed to setup operation #69" << std::endl;
3152 return ExecutionPlan();
3153 }
3154
3155 status = xnn_setup_hardswish_nc_f32(
3156 op70,
3157 196 /* batch size */,
3158 &v70[0] /* input */, &v71[0] /* output */,
3159 threadpool /* threadpool */);
3160 if (status != xnn_status_success) {
3161 std::cerr << "failed to setup operation #70" << std::endl;
3162 return ExecutionPlan();
3163 }
3164
3165 status = xnn_setup_global_average_pooling_nwc_f32(
3166 op71,
3167 1 /* batch size */, 196 /* width */,
3168 &v71[0] /* input */, &v72[0] /* output */,
3169 threadpool /* threadpool */);
3170 if (status != xnn_status_success) {
3171 std::cerr << "failed to setup operation #71" << std::endl;
3172 return ExecutionPlan();
3173 }
3174
3175 status = xnn_setup_convolution2d_nhwc_f32(
3176 op72,
3177 1 /* batch size */, 1 /* input height */, 1 /* input width */,
3178 &v72[0] /* input */, &v73[0] /* output */,
3179 threadpool /* threadpool */);
3180 if (status != xnn_status_success) {
3181 std::cerr << "failed to setup operation #72" << std::endl;
3182 return ExecutionPlan();
3183 }
3184
3185 status = xnn_setup_convolution2d_nhwc_f32(
3186 op73,
3187 1 /* batch size */, 1 /* input height */, 1 /* input width */,
3188 &v73[0] /* input */, &v74[0] /* output */,
3189 threadpool /* threadpool */);
3190 if (status != xnn_status_success) {
3191 std::cerr << "failed to setup operation #73" << std::endl;
3192 return ExecutionPlan();
3193 }
3194
3195 {
3196 const size_t a_shape[] = { 1, 14, 14, 672 };
3197 const size_t b_shape[] = { 1, 1, 1, 672 };
3198 status = xnn_setup_multiply_nd_f32(
3199 op74,
3200 4, a_shape, 4, b_shape,
3201 &v71[0] /* a */, &v74[0] /* b */, &v75[0] /* output */,
3202 threadpool /* threadpool */);
3203 }
3204 if (status != xnn_status_success) {
3205 std::cerr << "failed to setup operation #74" << std::endl;
3206 return ExecutionPlan();
3207 }
3208
3209 status = xnn_setup_convolution2d_nhwc_f32(
3210 op75,
3211 1 /* batch size */, 14 /* input height */, 14 /* input width */,
3212 &v75[0] /* input */, &v76[0] /* output */,
3213 threadpool /* threadpool */);
3214 if (status != xnn_status_success) {
3215 std::cerr << "failed to setup operation #75" << std::endl;
3216 return ExecutionPlan();
3217 }
3218
3219 status = xnn_setup_add_nc_f32(
3220 op76,
3221 196 /* batch size */,
3222 &v76[0] /* a */, &v67[0] /* b */, &v77[0] /* sum */,
3223 threadpool /* threadpool */);
3224 if (status != xnn_status_success) {
3225 std::cerr << "failed to setup operation #76" << std::endl;
3226 return ExecutionPlan();
3227 }
3228
3229 status = xnn_setup_convolution2d_nhwc_f32(
3230 op77,
3231 1 /* batch size */, 14 /* input height */, 14 /* input width */,
3232 &v77[0] /* input */, &v78[0] /* output */,
3233 threadpool /* threadpool */);
3234 if (status != xnn_status_success) {
3235 std::cerr << "failed to setup operation #77" << std::endl;
3236 return ExecutionPlan();
3237 }
3238
3239 status = xnn_setup_hardswish_nc_f32(
3240 op78,
3241 196 /* batch size */,
3242 &v78[0] /* input */, &v79[0] /* output */,
3243 threadpool /* threadpool */);
3244 if (status != xnn_status_success) {
3245 std::cerr << "failed to setup operation #78" << std::endl;
3246 return ExecutionPlan();
3247 }
3248
3249 status = xnn_setup_convolution2d_nhwc_f32(
3250 op79,
3251 1 /* batch size */, 14 /* input height */, 14 /* input width */,
3252 &v79[0] /* input */, &v80[0] /* output */,
3253 threadpool /* threadpool */);
3254 if (status != xnn_status_success) {
3255 std::cerr << "failed to setup operation #79" << std::endl;
3256 return ExecutionPlan();
3257 }
3258
3259 status = xnn_setup_hardswish_nc_f32(
3260 op80,
3261 49 /* batch size */,
3262 &v80[0] /* input */, &v81[0] /* output */,
3263 threadpool /* threadpool */);
3264 if (status != xnn_status_success) {
3265 std::cerr << "failed to setup operation #80" << std::endl;
3266 return ExecutionPlan();
3267 }
3268
3269 status = xnn_setup_global_average_pooling_nwc_f32(
3270 op81,
3271 1 /* batch size */, 49 /* width */,
3272 &v81[0] /* input */, &v82[0] /* output */,
3273 threadpool /* threadpool */);
3274 if (status != xnn_status_success) {
3275 std::cerr << "failed to setup operation #81" << std::endl;
3276 return ExecutionPlan();
3277 }
3278
3279 status = xnn_setup_convolution2d_nhwc_f32(
3280 op82,
3281 1 /* batch size */, 1 /* input height */, 1 /* input width */,
3282 &v82[0] /* input */, &v83[0] /* output */,
3283 threadpool /* threadpool */);
3284 if (status != xnn_status_success) {
3285 std::cerr << "failed to setup operation #82" << std::endl;
3286 return ExecutionPlan();
3287 }
3288
3289 status = xnn_setup_convolution2d_nhwc_f32(
3290 op83,
3291 1 /* batch size */, 1 /* input height */, 1 /* input width */,
3292 &v83[0] /* input */, &v84[0] /* output */,
3293 threadpool /* threadpool */);
3294 if (status != xnn_status_success) {
3295 std::cerr << "failed to setup operation #83" << std::endl;
3296 return ExecutionPlan();
3297 }
3298
3299 {
3300 const size_t a_shape[] = { 1, 7, 7, 672 };
3301 const size_t b_shape[] = { 1, 1, 1, 672 };
3302 status = xnn_setup_multiply_nd_f32(
3303 op84,
3304 4, a_shape, 4, b_shape,
3305 &v81[0] /* a */, &v84[0] /* b */, &v85[0] /* output */,
3306 threadpool /* threadpool */);
3307 }
3308 if (status != xnn_status_success) {
3309 std::cerr << "failed to setup operation #84" << std::endl;
3310 return ExecutionPlan();
3311 }
3312
3313 status = xnn_setup_convolution2d_nhwc_f32(
3314 op85,
3315 1 /* batch size */, 7 /* input height */, 7 /* input width */,
3316 &v85[0] /* input */, &v86[0] /* output */,
3317 threadpool /* threadpool */);
3318 if (status != xnn_status_success) {
3319 std::cerr << "failed to setup operation #85" << std::endl;
3320 return ExecutionPlan();
3321 }
3322
3323 status = xnn_setup_convolution2d_nhwc_f32(
3324 op86,
3325 1 /* batch size */, 7 /* input height */, 7 /* input width */,
3326 &v86[0] /* input */, &v87[0] /* output */,
3327 threadpool /* threadpool */);
3328 if (status != xnn_status_success) {
3329 std::cerr << "failed to setup operation #86" << std::endl;
3330 return ExecutionPlan();
3331 }
3332
3333 status = xnn_setup_hardswish_nc_f32(
3334 op87,
3335 49 /* batch size */,
3336 &v87[0] /* input */, &v88[0] /* output */,
3337 threadpool /* threadpool */);
3338 if (status != xnn_status_success) {
3339 std::cerr << "failed to setup operation #87" << std::endl;
3340 return ExecutionPlan();
3341 }
3342
3343 status = xnn_setup_convolution2d_nhwc_f32(
3344 op88,
3345 1 /* batch size */, 7 /* input height */, 7 /* input width */,
3346 &v88[0] /* input */, &v89[0] /* output */,
3347 threadpool /* threadpool */);
3348 if (status != xnn_status_success) {
3349 std::cerr << "failed to setup operation #88" << std::endl;
3350 return ExecutionPlan();
3351 }
3352
3353 status = xnn_setup_hardswish_nc_f32(
3354 op89,
3355 49 /* batch size */,
3356 &v89[0] /* input */, &v90[0] /* output */,
3357 threadpool /* threadpool */);
3358 if (status != xnn_status_success) {
3359 std::cerr << "failed to setup operation #89" << std::endl;
3360 return ExecutionPlan();
3361 }
3362
3363 status = xnn_setup_global_average_pooling_nwc_f32(
3364 op90,
3365 1 /* batch size */, 49 /* width */,
3366 &v90[0] /* input */, &v91[0] /* output */,
3367 threadpool /* threadpool */);
3368 if (status != xnn_status_success) {
3369 std::cerr << "failed to setup operation #90" << std::endl;
3370 return ExecutionPlan();
3371 }
3372
3373 status = xnn_setup_convolution2d_nhwc_f32(
3374 op91,
3375 1 /* batch size */, 1 /* input height */, 1 /* input width */,
3376 &v91[0] /* input */, &v92[0] /* output */,
3377 threadpool /* threadpool */);
3378 if (status != xnn_status_success) {
3379 std::cerr << "failed to setup operation #91" << std::endl;
3380 return ExecutionPlan();
3381 }
3382
3383 status = xnn_setup_convolution2d_nhwc_f32(
3384 op92,
3385 1 /* batch size */, 1 /* input height */, 1 /* input width */,
3386 &v92[0] /* input */, &v93[0] /* output */,
3387 threadpool /* threadpool */);
3388 if (status != xnn_status_success) {
3389 std::cerr << "failed to setup operation #92" << std::endl;
3390 return ExecutionPlan();
3391 }
3392
3393 {
3394 const size_t a_shape[] = { 1, 7, 7, 960 };
3395 const size_t b_shape[] = { 1, 1, 1, 960 };
3396 status = xnn_setup_multiply_nd_f32(
3397 op93,
3398 4, a_shape, 4, b_shape,
3399 &v90[0] /* a */, &v93[0] /* b */, &v94[0] /* output */,
3400 threadpool /* threadpool */);
3401 }
3402 if (status != xnn_status_success) {
3403 std::cerr << "failed to setup operation #93" << std::endl;
3404 return ExecutionPlan();
3405 }
3406
3407 status = xnn_setup_convolution2d_nhwc_f32(
3408 op94,
3409 1 /* batch size */, 7 /* input height */, 7 /* input width */,
3410 &v94[0] /* input */, &v95[0] /* output */,
3411 threadpool /* threadpool */);
3412 if (status != xnn_status_success) {
3413 std::cerr << "failed to setup operation #94" << std::endl;
3414 return ExecutionPlan();
3415 }
3416
3417 status = xnn_setup_add_nc_f32(
3418 op95,
3419 49 /* batch size */,
3420 &v95[0] /* a */, &v86[0] /* b */, &v96[0] /* sum */,
3421 threadpool /* threadpool */);
3422 if (status != xnn_status_success) {
3423 std::cerr << "failed to setup operation #95" << std::endl;
3424 return ExecutionPlan();
3425 }
3426
3427 status = xnn_setup_convolution2d_nhwc_f32(
3428 op96,
3429 1 /* batch size */, 7 /* input height */, 7 /* input width */,
3430 &v96[0] /* input */, &v97[0] /* output */,
3431 threadpool /* threadpool */);
3432 if (status != xnn_status_success) {
3433 std::cerr << "failed to setup operation #96" << std::endl;
3434 return ExecutionPlan();
3435 }
3436
3437 status = xnn_setup_hardswish_nc_f32(
3438 op97,
3439 49 /* batch size */,
3440 &v97[0] /* input */, &v98[0] /* output */,
3441 threadpool /* threadpool */);
3442 if (status != xnn_status_success) {
3443 std::cerr << "failed to setup operation #97" << std::endl;
3444 return ExecutionPlan();
3445 }
3446
3447 status = xnn_setup_convolution2d_nhwc_f32(
3448 op98,
3449 1 /* batch size */, 7 /* input height */, 7 /* input width */,
3450 &v98[0] /* input */, &v99[0] /* output */,
3451 threadpool /* threadpool */);
3452 if (status != xnn_status_success) {
3453 std::cerr << "failed to setup operation #98" << std::endl;
3454 return ExecutionPlan();
3455 }
3456
3457 status = xnn_setup_hardswish_nc_f32(
3458 op99,
3459 49 /* batch size */,
3460 &v99[0] /* input */, &v100[0] /* output */,
3461 threadpool /* threadpool */);
3462 if (status != xnn_status_success) {
3463 std::cerr << "failed to setup operation #99" << std::endl;
3464 return ExecutionPlan();
3465 }
3466
3467 status = xnn_setup_global_average_pooling_nwc_f32(
3468 op100,
3469 1 /* batch size */, 49 /* width */,
3470 &v100[0] /* input */, &v101[0] /* output */,
3471 threadpool /* threadpool */);
3472 if (status != xnn_status_success) {
3473 std::cerr << "failed to setup operation #100" << std::endl;
3474 return ExecutionPlan();
3475 }
3476
3477 status = xnn_setup_convolution2d_nhwc_f32(
3478 op101,
3479 1 /* batch size */, 1 /* input height */, 1 /* input width */,
3480 &v101[0] /* input */, &v102[0] /* output */,
3481 threadpool /* threadpool */);
3482 if (status != xnn_status_success) {
3483 std::cerr << "failed to setup operation #101" << std::endl;
3484 return ExecutionPlan();
3485 }
3486
3487 status = xnn_setup_convolution2d_nhwc_f32(
3488 op102,
3489 1 /* batch size */, 1 /* input height */, 1 /* input width */,
3490 &v102[0] /* input */, &v103[0] /* output */,
3491 threadpool /* threadpool */);
3492 if (status != xnn_status_success) {
3493 std::cerr << "failed to setup operation #102" << std::endl;
3494 return ExecutionPlan();
3495 }
3496
3497 {
3498 const size_t a_shape[] = { 1, 7, 7, 960 };
3499 const size_t b_shape[] = { 1, 1, 1, 960 };
3500 status = xnn_setup_multiply_nd_f32(
3501 op103,
3502 4, a_shape, 4, b_shape,
3503 &v100[0] /* a */, &v103[0] /* b */, &v104[0] /* output */,
3504 threadpool /* threadpool */);
3505 }
3506 if (status != xnn_status_success) {
3507 std::cerr << "failed to setup operation #103" << std::endl;
3508 return ExecutionPlan();
3509 }
3510
3511 status = xnn_setup_convolution2d_nhwc_f32(
3512 op104,
3513 1 /* batch size */, 7 /* input height */, 7 /* input width */,
3514 &v104[0] /* input */, &v105[0] /* output */,
3515 threadpool /* threadpool */);
3516 if (status != xnn_status_success) {
3517 std::cerr << "failed to setup operation #104" << std::endl;
3518 return ExecutionPlan();
3519 }
3520
3521 status = xnn_setup_add_nc_f32(
3522 op105,
3523 49 /* batch size */,
3524 &v105[0] /* a */, &v96[0] /* b */, &v106[0] /* sum */,
3525 threadpool /* threadpool */);
3526 if (status != xnn_status_success) {
3527 std::cerr << "failed to setup operation #105" << std::endl;
3528 return ExecutionPlan();
3529 }
3530
3531 status = xnn_setup_convolution2d_nhwc_f32(
3532 op106,
3533 1 /* batch size */, 7 /* input height */, 7 /* input width */,
3534 &v106[0] /* input */, &v107[0] /* output */,
3535 threadpool /* threadpool */);
3536 if (status != xnn_status_success) {
3537 std::cerr << "failed to setup operation #106" << std::endl;
3538 return ExecutionPlan();
3539 }
3540
3541 status = xnn_setup_hardswish_nc_f32(
3542 op107,
3543 49 /* batch size */,
3544 &v107[0] /* input */, &v108[0] /* output */,
3545 threadpool /* threadpool */);
3546 if (status != xnn_status_success) {
3547 std::cerr << "failed to setup operation #107" << std::endl;
3548 return ExecutionPlan();
3549 }
3550
3551 status = xnn_setup_global_average_pooling_nwc_f32(
3552 op108,
3553 1 /* batch size */, 49 /* width */,
3554 &v108[0] /* input */, &v109[0] /* output */,
3555 threadpool /* threadpool */);
3556 if (status != xnn_status_success) {
3557 std::cerr << "failed to setup operation #108" << std::endl;
3558 return ExecutionPlan();
3559 }
3560
3561 status = xnn_setup_convolution2d_nhwc_f32(
3562 op109,
3563 1 /* batch size */, 1 /* input height */, 1 /* input width */,
3564 &v109[0] /* input */, &v110[0] /* output */,
3565 threadpool /* threadpool */);
3566 if (status != xnn_status_success) {
3567 std::cerr << "failed to setup operation #109" << std::endl;
3568 return ExecutionPlan();
3569 }
3570
3571 status = xnn_setup_hardswish_nc_f32(
3572 op110,
3573 1 /* batch size */,
3574 &v110[0] /* input */, &v111[0] /* output */,
3575 threadpool /* threadpool */);
3576 if (status != xnn_status_success) {
3577 std::cerr << "failed to setup operation #110" << std::endl;
3578 return ExecutionPlan();
3579 }
3580
3581 status = xnn_setup_global_average_pooling_nwc_f32(
3582 op111,
3583 1 /* batch size */, 1 /* width */,
3584 &v111[0] /* input */, &v112[0] /* output */,
3585 threadpool /* threadpool */);
3586 if (status != xnn_status_success) {
3587 std::cerr << "failed to setup operation #111" << std::endl;
3588 return ExecutionPlan();
3589 }
3590
3591 status = xnn_setup_convolution2d_nhwc_f32(
3592 op112,
3593 1 /* batch size */, 1 /* input height */, 1 /* input width */,
3594 &v112[0] /* input */, &v113[0] /* output */,
3595 threadpool /* threadpool */);
3596 if (status != xnn_status_success) {
3597 std::cerr << "failed to setup operation #112" << std::endl;
3598 return ExecutionPlan();
3599 }
3600
3601 #pragma clang diagnostic push
3602 #pragma clang diagnostic ignored "-Wpessimizing-move"
3603 return operators;
3604 #pragma clang diagnostic pop
3605}
3606
3607} // namespace models