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