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