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