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