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