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