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