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