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