• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // Copyright 2020 Google LLC
2 //
3 // This source code is licensed under the BSD-style license found in the
4 // LICENSE file in the root directory of this source tree.
5 
6 #include <xnnpack.h>
7 
8 #include <array>
9 #include <algorithm>
10 #include <functional>
11 #include <iostream>
12 #include <limits>
13 #include <random>
14 
15 #include <fp16/fp16.h>
16 
17 #include "models/models.h"
18 
19 namespace models {
20 
FP16MobileNetV2(pthreadpool_t threadpool)21 ExecutionPlan FP16MobileNetV2(pthreadpool_t threadpool) {
22   alignas(16) static std::array<uint16_t, 150528> v0;
23   alignas(16) static std::array<uint16_t, 401408> v1;
24   alignas(16) static std::array<uint16_t, 401408> v2;
25   alignas(16) static std::array<uint16_t, 200704> v3;
26   alignas(16) static std::array<uint16_t, 1204224> v4;
27   alignas(16) static std::array<uint16_t, 301056> v5;
28   alignas(16) static std::array<uint16_t, 75264> v6;
29   alignas(16) static std::array<uint16_t, 451584> v7;
30   alignas(16) static std::array<uint16_t, 451584> v8;
31   alignas(16) static std::array<uint16_t, 75264> v9;
32   alignas(16) static std::array<uint16_t, 75264> v10;
33   alignas(16) static std::array<uint16_t, 451584> v11;
34   alignas(16) static std::array<uint16_t, 112896> v12;
35   alignas(16) static std::array<uint16_t, 25088> v13;
36   alignas(16) static std::array<uint16_t, 150528> v14;
37   alignas(16) static std::array<uint16_t, 150528> v15;
38   alignas(16) static std::array<uint16_t, 25088> v16;
39   alignas(16) static std::array<uint16_t, 25088> v17;
40   alignas(16) static std::array<uint16_t, 150528> v18;
41   alignas(16) static std::array<uint16_t, 150528> v19;
42   alignas(16) static std::array<uint16_t, 25088> v20;
43   alignas(16) static std::array<uint16_t, 25088> v21;
44   alignas(16) static std::array<uint16_t, 150528> v22;
45   alignas(16) static std::array<uint16_t, 37632> v23;
46   alignas(16) static std::array<uint16_t, 12544> v24;
47   alignas(16) static std::array<uint16_t, 75264> v25;
48   alignas(16) static std::array<uint16_t, 75264> v26;
49   alignas(16) static std::array<uint16_t, 12544> v27;
50   alignas(16) static std::array<uint16_t, 12544> v28;
51   alignas(16) static std::array<uint16_t, 75264> v29;
52   alignas(16) static std::array<uint16_t, 75264> v30;
53   alignas(16) static std::array<uint16_t, 12544> v31;
54   alignas(16) static std::array<uint16_t, 12544> v32;
55   alignas(16) static std::array<uint16_t, 75264> v33;
56   alignas(16) static std::array<uint16_t, 75264> v34;
57   alignas(16) static std::array<uint16_t, 12544> v35;
58   alignas(16) static std::array<uint16_t, 12544> v36;
59   alignas(16) static std::array<uint16_t, 75264> v37;
60   alignas(16) static std::array<uint16_t, 75264> v38;
61   alignas(16) static std::array<uint16_t, 18816> v39;
62   alignas(16) static std::array<uint16_t, 112896> v40;
63   alignas(16) static std::array<uint16_t, 112896> v41;
64   alignas(16) static std::array<uint16_t, 18816> v42;
65   alignas(16) static std::array<uint16_t, 18816> v43;
66   alignas(16) static std::array<uint16_t, 112896> v44;
67   alignas(16) static std::array<uint16_t, 112896> v45;
68   alignas(16) static std::array<uint16_t, 18816> v46;
69   alignas(16) static std::array<uint16_t, 18816> v47;
70   alignas(16) static std::array<uint16_t, 112896> v48;
71   alignas(16) static std::array<uint16_t, 28224> v49;
72   alignas(16) static std::array<uint16_t, 7840> v50;
73   alignas(16) static std::array<uint16_t, 47040> v51;
74   alignas(16) static std::array<uint16_t, 47040> v52;
75   alignas(16) static std::array<uint16_t, 7840> v53;
76   alignas(16) static std::array<uint16_t, 7840> v54;
77   alignas(16) static std::array<uint16_t, 47040> v55;
78   alignas(16) static std::array<uint16_t, 47040> v56;
79   alignas(16) static std::array<uint16_t, 7840> v57;
80   alignas(16) static std::array<uint16_t, 7840> v58;
81   alignas(16) static std::array<uint16_t, 47040> v59;
82   alignas(16) static std::array<uint16_t, 47040> v60;
83   alignas(16) static std::array<uint16_t, 15680> v61;
84   alignas(16) static std::array<uint16_t, 62720> v62;
85   alignas(16) static std::array<uint16_t, 1280> v63;
86   alignas(16) static std::array<uint16_t, 1001> v64;
87   alignas(16) static std::array<uint16_t, 864> w65;
88   alignas(16) static std::array<uint16_t, 32> w66;
89   alignas(16) static std::array<uint16_t, 288> w67;
90   alignas(16) static std::array<uint16_t, 32> w68;
91   alignas(16) static std::array<uint16_t, 512> w69;
92   alignas(16) static std::array<uint16_t, 16> w70;
93   alignas(16) static std::array<uint16_t, 1536> w71;
94   alignas(16) static std::array<uint16_t, 96> w72;
95   alignas(16) static std::array<uint16_t, 864> w73;
96   alignas(16) static std::array<uint16_t, 96> w74;
97   alignas(16) static std::array<uint16_t, 2304> w75;
98   alignas(16) static std::array<uint16_t, 24> w76;
99   alignas(16) static std::array<uint16_t, 3456> w77;
100   alignas(16) static std::array<uint16_t, 144> w78;
101   alignas(16) static std::array<uint16_t, 1296> w79;
102   alignas(16) static std::array<uint16_t, 144> w80;
103   alignas(16) static std::array<uint16_t, 3456> w81;
104   alignas(16) static std::array<uint16_t, 24> w82;
105   alignas(16) static std::array<uint16_t, 3456> w83;
106   alignas(16) static std::array<uint16_t, 144> w84;
107   alignas(16) static std::array<uint16_t, 1296> w85;
108   alignas(16) static std::array<uint16_t, 144> w86;
109   alignas(16) static std::array<uint16_t, 4608> w87;
110   alignas(16) static std::array<uint16_t, 32> w88;
111   alignas(16) static std::array<uint16_t, 6144> w89;
112   alignas(16) static std::array<uint16_t, 192> w90;
113   alignas(16) static std::array<uint16_t, 1728> w91;
114   alignas(16) static std::array<uint16_t, 192> w92;
115   alignas(16) static std::array<uint16_t, 6144> w93;
116   alignas(16) static std::array<uint16_t, 32> w94;
117   alignas(16) static std::array<uint16_t, 6144> w95;
118   alignas(16) static std::array<uint16_t, 192> w96;
119   alignas(16) static std::array<uint16_t, 1728> w97;
120   alignas(16) static std::array<uint16_t, 192> w98;
121   alignas(16) static std::array<uint16_t, 6144> w99;
122   alignas(16) static std::array<uint16_t, 32> w100;
123   alignas(16) static std::array<uint16_t, 6144> w101;
124   alignas(16) static std::array<uint16_t, 192> w102;
125   alignas(16) static std::array<uint16_t, 1728> w103;
126   alignas(16) static std::array<uint16_t, 192> w104;
127   alignas(16) static std::array<uint16_t, 12288> w105;
128   alignas(16) static std::array<uint16_t, 64> w106;
129   alignas(16) static std::array<uint16_t, 24576> w107;
130   alignas(16) static std::array<uint16_t, 384> w108;
131   alignas(16) static std::array<uint16_t, 3456> w109;
132   alignas(16) static std::array<uint16_t, 384> w110;
133   alignas(16) static std::array<uint16_t, 24576> w111;
134   alignas(16) static std::array<uint16_t, 64> w112;
135   alignas(16) static std::array<uint16_t, 24576> w113;
136   alignas(16) static std::array<uint16_t, 384> w114;
137   alignas(16) static std::array<uint16_t, 3456> w115;
138   alignas(16) static std::array<uint16_t, 384> w116;
139   alignas(16) static std::array<uint16_t, 24576> w117;
140   alignas(16) static std::array<uint16_t, 64> w118;
141   alignas(16) static std::array<uint16_t, 24576> w119;
142   alignas(16) static std::array<uint16_t, 384> w120;
143   alignas(16) static std::array<uint16_t, 3456> w121;
144   alignas(16) static std::array<uint16_t, 384> w122;
145   alignas(16) static std::array<uint16_t, 24576> w123;
146   alignas(16) static std::array<uint16_t, 64> w124;
147   alignas(16) static std::array<uint16_t, 24576> w125;
148   alignas(16) static std::array<uint16_t, 384> w126;
149   alignas(16) static std::array<uint16_t, 3456> w127;
150   alignas(16) static std::array<uint16_t, 384> w128;
151   alignas(16) static std::array<uint16_t, 36864> w129;
152   alignas(16) static std::array<uint16_t, 96> w130;
153   alignas(16) static std::array<uint16_t, 55296> w131;
154   alignas(16) static std::array<uint16_t, 576> w132;
155   alignas(16) static std::array<uint16_t, 5184> w133;
156   alignas(16) static std::array<uint16_t, 576> w134;
157   alignas(16) static std::array<uint16_t, 55296> w135;
158   alignas(16) static std::array<uint16_t, 96> w136;
159   alignas(16) static std::array<uint16_t, 55296> w137;
160   alignas(16) static std::array<uint16_t, 576> w138;
161   alignas(16) static std::array<uint16_t, 5184> w139;
162   alignas(16) static std::array<uint16_t, 576> w140;
163   alignas(16) static std::array<uint16_t, 55296> w141;
164   alignas(16) static std::array<uint16_t, 96> w142;
165   alignas(16) static std::array<uint16_t, 55296> w143;
166   alignas(16) static std::array<uint16_t, 576> w144;
167   alignas(16) static std::array<uint16_t, 5184> w145;
168   alignas(16) static std::array<uint16_t, 576> w146;
169   alignas(16) static std::array<uint16_t, 92160> w147;
170   alignas(16) static std::array<uint16_t, 160> w148;
171   alignas(16) static std::array<uint16_t, 153600> w149;
172   alignas(16) static std::array<uint16_t, 960> w150;
173   alignas(16) static std::array<uint16_t, 8640> w151;
174   alignas(16) static std::array<uint16_t, 960> w152;
175   alignas(16) static std::array<uint16_t, 153600> w153;
176   alignas(16) static std::array<uint16_t, 160> w154;
177   alignas(16) static std::array<uint16_t, 153600> w155;
178   alignas(16) static std::array<uint16_t, 960> w156;
179   alignas(16) static std::array<uint16_t, 8640> w157;
180   alignas(16) static std::array<uint16_t, 960> w158;
181   alignas(16) static std::array<uint16_t, 153600> w159;
182   alignas(16) static std::array<uint16_t, 160> w160;
183   alignas(16) static std::array<uint16_t, 153600> w161;
184   alignas(16) static std::array<uint16_t, 960> w162;
185   alignas(16) static std::array<uint16_t, 8640> w163;
186   alignas(16) static std::array<uint16_t, 960> w164;
187   alignas(16) static std::array<uint16_t, 307200> w165;
188   alignas(16) static std::array<uint16_t, 320> w166;
189   alignas(16) static std::array<uint16_t, 409600> w167;
190   alignas(16) static std::array<uint16_t, 1280> w168;
191   alignas(16) static std::array<uint16_t, 1281280> w169;
192   alignas(16) static std::array<uint16_t, 1001> w170;
193 
194   std::random_device random_device;
195   auto rng = std::mt19937(random_device());
196   auto f32rng = std::bind(std::uniform_real_distribution<float>(-1.0f, +1.0f), std::ref(rng));
197   auto f16rng = std::bind(fp16_ieee_from_fp32_value, f32rng);
198   std::generate(v0.begin(), v0.end(), std::ref(f16rng));
199   std::generate(v1.begin(), v1.end(), std::ref(f16rng));
200   std::generate(v2.begin(), v2.end(), std::ref(f16rng));
201   std::generate(v3.begin(), v3.end(), std::ref(f16rng));
202   std::generate(v4.begin(), v4.end(), std::ref(f16rng));
203   std::generate(v5.begin(), v5.end(), std::ref(f16rng));
204   std::generate(v6.begin(), v6.end(), std::ref(f16rng));
205   std::generate(v7.begin(), v7.end(), std::ref(f16rng));
206   std::generate(v8.begin(), v8.end(), std::ref(f16rng));
207   std::generate(v9.begin(), v9.end(), std::ref(f16rng));
208   std::generate(v10.begin(), v10.end(), std::ref(f16rng));
209   std::generate(v11.begin(), v11.end(), std::ref(f16rng));
210   std::generate(v12.begin(), v12.end(), std::ref(f16rng));
211   std::generate(v13.begin(), v13.end(), std::ref(f16rng));
212   std::generate(v14.begin(), v14.end(), std::ref(f16rng));
213   std::generate(v15.begin(), v15.end(), std::ref(f16rng));
214   std::generate(v16.begin(), v16.end(), std::ref(f16rng));
215   std::generate(v17.begin(), v17.end(), std::ref(f16rng));
216   std::generate(v18.begin(), v18.end(), std::ref(f16rng));
217   std::generate(v19.begin(), v19.end(), std::ref(f16rng));
218   std::generate(v20.begin(), v20.end(), std::ref(f16rng));
219   std::generate(v21.begin(), v21.end(), std::ref(f16rng));
220   std::generate(v22.begin(), v22.end(), std::ref(f16rng));
221   std::generate(v23.begin(), v23.end(), std::ref(f16rng));
222   std::generate(v24.begin(), v24.end(), std::ref(f16rng));
223   std::generate(v25.begin(), v25.end(), std::ref(f16rng));
224   std::generate(v26.begin(), v26.end(), std::ref(f16rng));
225   std::generate(v27.begin(), v27.end(), std::ref(f16rng));
226   std::generate(v28.begin(), v28.end(), std::ref(f16rng));
227   std::generate(v29.begin(), v29.end(), std::ref(f16rng));
228   std::generate(v30.begin(), v30.end(), std::ref(f16rng));
229   std::generate(v31.begin(), v31.end(), std::ref(f16rng));
230   std::generate(v32.begin(), v32.end(), std::ref(f16rng));
231   std::generate(v33.begin(), v33.end(), std::ref(f16rng));
232   std::generate(v34.begin(), v34.end(), std::ref(f16rng));
233   std::generate(v35.begin(), v35.end(), std::ref(f16rng));
234   std::generate(v36.begin(), v36.end(), std::ref(f16rng));
235   std::generate(v37.begin(), v37.end(), std::ref(f16rng));
236   std::generate(v38.begin(), v38.end(), std::ref(f16rng));
237   std::generate(v39.begin(), v39.end(), std::ref(f16rng));
238   std::generate(v40.begin(), v40.end(), std::ref(f16rng));
239   std::generate(v41.begin(), v41.end(), std::ref(f16rng));
240   std::generate(v42.begin(), v42.end(), std::ref(f16rng));
241   std::generate(v43.begin(), v43.end(), std::ref(f16rng));
242   std::generate(v44.begin(), v44.end(), std::ref(f16rng));
243   std::generate(v45.begin(), v45.end(), std::ref(f16rng));
244   std::generate(v46.begin(), v46.end(), std::ref(f16rng));
245   std::generate(v47.begin(), v47.end(), std::ref(f16rng));
246   std::generate(v48.begin(), v48.end(), std::ref(f16rng));
247   std::generate(v49.begin(), v49.end(), std::ref(f16rng));
248   std::generate(v50.begin(), v50.end(), std::ref(f16rng));
249   std::generate(v51.begin(), v51.end(), std::ref(f16rng));
250   std::generate(v52.begin(), v52.end(), std::ref(f16rng));
251   std::generate(v53.begin(), v53.end(), std::ref(f16rng));
252   std::generate(v54.begin(), v54.end(), std::ref(f16rng));
253   std::generate(v55.begin(), v55.end(), std::ref(f16rng));
254   std::generate(v56.begin(), v56.end(), std::ref(f16rng));
255   std::generate(v57.begin(), v57.end(), std::ref(f16rng));
256   std::generate(v58.begin(), v58.end(), std::ref(f16rng));
257   std::generate(v59.begin(), v59.end(), std::ref(f16rng));
258   std::generate(v60.begin(), v60.end(), std::ref(f16rng));
259   std::generate(v61.begin(), v61.end(), std::ref(f16rng));
260   std::generate(v62.begin(), v62.end(), std::ref(f16rng));
261   std::generate(v63.begin(), v63.end(), std::ref(f16rng));
262   std::generate(v64.begin(), v64.end(), std::ref(f16rng));
263   std::generate(w65.begin(), w65.end(), std::ref(f16rng));
264   std::generate(w66.begin(), w66.end(), std::ref(f16rng));
265   std::generate(w67.begin(), w67.end(), std::ref(f16rng));
266   std::generate(w68.begin(), w68.end(), std::ref(f16rng));
267   std::generate(w69.begin(), w69.end(), std::ref(f16rng));
268   std::generate(w70.begin(), w70.end(), std::ref(f16rng));
269   std::generate(w71.begin(), w71.end(), std::ref(f16rng));
270   std::generate(w72.begin(), w72.end(), std::ref(f16rng));
271   std::generate(w73.begin(), w73.end(), std::ref(f16rng));
272   std::generate(w74.begin(), w74.end(), std::ref(f16rng));
273   std::generate(w75.begin(), w75.end(), std::ref(f16rng));
274   std::generate(w76.begin(), w76.end(), std::ref(f16rng));
275   std::generate(w77.begin(), w77.end(), std::ref(f16rng));
276   std::generate(w78.begin(), w78.end(), std::ref(f16rng));
277   std::generate(w79.begin(), w79.end(), std::ref(f16rng));
278   std::generate(w80.begin(), w80.end(), std::ref(f16rng));
279   std::generate(w81.begin(), w81.end(), std::ref(f16rng));
280   std::generate(w82.begin(), w82.end(), std::ref(f16rng));
281   std::generate(w83.begin(), w83.end(), std::ref(f16rng));
282   std::generate(w84.begin(), w84.end(), std::ref(f16rng));
283   std::generate(w85.begin(), w85.end(), std::ref(f16rng));
284   std::generate(w86.begin(), w86.end(), std::ref(f16rng));
285   std::generate(w87.begin(), w87.end(), std::ref(f16rng));
286   std::generate(w88.begin(), w88.end(), std::ref(f16rng));
287   std::generate(w89.begin(), w89.end(), std::ref(f16rng));
288   std::generate(w90.begin(), w90.end(), std::ref(f16rng));
289   std::generate(w91.begin(), w91.end(), std::ref(f16rng));
290   std::generate(w92.begin(), w92.end(), std::ref(f16rng));
291   std::generate(w93.begin(), w93.end(), std::ref(f16rng));
292   std::generate(w94.begin(), w94.end(), std::ref(f16rng));
293   std::generate(w95.begin(), w95.end(), std::ref(f16rng));
294   std::generate(w96.begin(), w96.end(), std::ref(f16rng));
295   std::generate(w97.begin(), w97.end(), std::ref(f16rng));
296   std::generate(w98.begin(), w98.end(), std::ref(f16rng));
297   std::generate(w99.begin(), w99.end(), std::ref(f16rng));
298   std::generate(w100.begin(), w100.end(), std::ref(f16rng));
299   std::generate(w101.begin(), w101.end(), std::ref(f16rng));
300   std::generate(w102.begin(), w102.end(), std::ref(f16rng));
301   std::generate(w103.begin(), w103.end(), std::ref(f16rng));
302   std::generate(w104.begin(), w104.end(), std::ref(f16rng));
303   std::generate(w105.begin(), w105.end(), std::ref(f16rng));
304   std::generate(w106.begin(), w106.end(), std::ref(f16rng));
305   std::generate(w107.begin(), w107.end(), std::ref(f16rng));
306   std::generate(w108.begin(), w108.end(), std::ref(f16rng));
307   std::generate(w109.begin(), w109.end(), std::ref(f16rng));
308   std::generate(w110.begin(), w110.end(), std::ref(f16rng));
309   std::generate(w111.begin(), w111.end(), std::ref(f16rng));
310   std::generate(w112.begin(), w112.end(), std::ref(f16rng));
311   std::generate(w113.begin(), w113.end(), std::ref(f16rng));
312   std::generate(w114.begin(), w114.end(), std::ref(f16rng));
313   std::generate(w115.begin(), w115.end(), std::ref(f16rng));
314   std::generate(w116.begin(), w116.end(), std::ref(f16rng));
315   std::generate(w117.begin(), w117.end(), std::ref(f16rng));
316   std::generate(w118.begin(), w118.end(), std::ref(f16rng));
317   std::generate(w119.begin(), w119.end(), std::ref(f16rng));
318   std::generate(w120.begin(), w120.end(), std::ref(f16rng));
319   std::generate(w121.begin(), w121.end(), std::ref(f16rng));
320   std::generate(w122.begin(), w122.end(), std::ref(f16rng));
321   std::generate(w123.begin(), w123.end(), std::ref(f16rng));
322   std::generate(w124.begin(), w124.end(), std::ref(f16rng));
323   std::generate(w125.begin(), w125.end(), std::ref(f16rng));
324   std::generate(w126.begin(), w126.end(), std::ref(f16rng));
325   std::generate(w127.begin(), w127.end(), std::ref(f16rng));
326   std::generate(w128.begin(), w128.end(), std::ref(f16rng));
327   std::generate(w129.begin(), w129.end(), std::ref(f16rng));
328   std::generate(w130.begin(), w130.end(), std::ref(f16rng));
329   std::generate(w131.begin(), w131.end(), std::ref(f16rng));
330   std::generate(w132.begin(), w132.end(), std::ref(f16rng));
331   std::generate(w133.begin(), w133.end(), std::ref(f16rng));
332   std::generate(w134.begin(), w134.end(), std::ref(f16rng));
333   std::generate(w135.begin(), w135.end(), std::ref(f16rng));
334   std::generate(w136.begin(), w136.end(), std::ref(f16rng));
335   std::generate(w137.begin(), w137.end(), std::ref(f16rng));
336   std::generate(w138.begin(), w138.end(), std::ref(f16rng));
337   std::generate(w139.begin(), w139.end(), std::ref(f16rng));
338   std::generate(w140.begin(), w140.end(), std::ref(f16rng));
339   std::generate(w141.begin(), w141.end(), std::ref(f16rng));
340   std::generate(w142.begin(), w142.end(), std::ref(f16rng));
341   std::generate(w143.begin(), w143.end(), std::ref(f16rng));
342   std::generate(w144.begin(), w144.end(), std::ref(f16rng));
343   std::generate(w145.begin(), w145.end(), std::ref(f16rng));
344   std::generate(w146.begin(), w146.end(), std::ref(f16rng));
345   std::generate(w147.begin(), w147.end(), std::ref(f16rng));
346   std::generate(w148.begin(), w148.end(), std::ref(f16rng));
347   std::generate(w149.begin(), w149.end(), std::ref(f16rng));
348   std::generate(w150.begin(), w150.end(), std::ref(f16rng));
349   std::generate(w151.begin(), w151.end(), std::ref(f16rng));
350   std::generate(w152.begin(), w152.end(), std::ref(f16rng));
351   std::generate(w153.begin(), w153.end(), std::ref(f16rng));
352   std::generate(w154.begin(), w154.end(), std::ref(f16rng));
353   std::generate(w155.begin(), w155.end(), std::ref(f16rng));
354   std::generate(w156.begin(), w156.end(), std::ref(f16rng));
355   std::generate(w157.begin(), w157.end(), std::ref(f16rng));
356   std::generate(w158.begin(), w158.end(), std::ref(f16rng));
357   std::generate(w159.begin(), w159.end(), std::ref(f16rng));
358   std::generate(w160.begin(), w160.end(), std::ref(f16rng));
359   std::generate(w161.begin(), w161.end(), std::ref(f16rng));
360   std::generate(w162.begin(), w162.end(), std::ref(f16rng));
361   std::generate(w163.begin(), w163.end(), std::ref(f16rng));
362   std::generate(w164.begin(), w164.end(), std::ref(f16rng));
363   std::generate(w165.begin(), w165.end(), std::ref(f16rng));
364   std::generate(w166.begin(), w166.end(), std::ref(f16rng));
365   std::generate(w167.begin(), w167.end(), std::ref(f16rng));
366   std::generate(w168.begin(), w168.end(), std::ref(f16rng));
367   std::generate(w169.begin(), w169.end(), std::ref(f16rng));
368   std::generate(w170.begin(), w170.end(), std::ref(f16rng));
369 
370   ExecutionPlan operators;
371   xnn_status status;
372 
373   xnn_operator_t op0 = nullptr;
374   status = xnn_create_convolution2d_nhwc_f16(
375     0 /* top padding */, 1 /* right padding */,
376     1 /* bottom padding */, 0 /* left padding */,
377     3 /* kernel height */, 3 /* kernel width */,
378     2 /* subsampling height */, 2 /* subsampling width */,
379     1 /* dilation_height */, 1 /* dilation_width */,
380     1 /* groups */,
381     3 /* input channels per group */,
382     32 /* output_channels_per_group */,
383     3 /* input pixel stride */,
384     32 /* output pixel stride */,
385     w65.data(), w66.data(),
386     0.0f /* output min */, 6.0f /* output max */,
387     0 /* flags */,
388     &op0);
389   if (status != xnn_status_success) {
390     std::cerr << "failed to create operation #0" << std::endl;
391     return ExecutionPlan();
392   }
393   operators.emplace_back(op0, xnn_delete_operator);
394 
395   xnn_operator_t op1 = nullptr;
396   status = xnn_create_convolution2d_nhwc_f16(
397     1 /* top padding */, 1 /* right padding */,
398     1 /* bottom padding */, 1 /* left padding */,
399     3 /* kernel height */, 3 /* kernel width */,
400     1 /* subsampling height */, 1 /* subsampling width */,
401     1 /* dilation_height */, 1 /* dilation_width */,
402     32 /* groups */,
403     1 /* input channels per group */,
404     1 /* output_channels_per_group */,
405     32 /* input pixel stride */,
406     32 /* output pixel stride */,
407     w67.data(), w68.data(),
408     0.0f /* output min */, 6.0f /* output max */,
409     0 /* flags */,
410     &op1);
411   if (status != xnn_status_success) {
412     std::cerr << "failed to create operation #1" << std::endl;
413     return ExecutionPlan();
414   }
415   operators.emplace_back(op1, xnn_delete_operator);
416 
417   xnn_operator_t op2 = nullptr;
418   status = xnn_create_convolution2d_nhwc_f16(
419     0 /* top padding */, 0 /* right padding */,
420     0 /* bottom padding */, 0 /* left padding */,
421     1 /* kernel height */, 1 /* kernel width */,
422     1 /* subsampling height */, 1 /* subsampling width */,
423     1 /* dilation_height */, 1 /* dilation_width */,
424     1 /* groups */,
425     32 /* input channels per group */,
426     16 /* output_channels_per_group */,
427     32 /* input pixel stride */,
428     16 /* output pixel stride */,
429     w69.data(), w70.data(),
430     -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
431     0 /* flags */,
432     &op2);
433   if (status != xnn_status_success) {
434     std::cerr << "failed to create operation #2" << std::endl;
435     return ExecutionPlan();
436   }
437   operators.emplace_back(op2, xnn_delete_operator);
438 
439   xnn_operator_t op3 = nullptr;
440   status = xnn_create_convolution2d_nhwc_f16(
441     0 /* top padding */, 0 /* right padding */,
442     0 /* bottom padding */, 0 /* left padding */,
443     1 /* kernel height */, 1 /* kernel width */,
444     1 /* subsampling height */, 1 /* subsampling width */,
445     1 /* dilation_height */, 1 /* dilation_width */,
446     1 /* groups */,
447     16 /* input channels per group */,
448     96 /* output_channels_per_group */,
449     16 /* input pixel stride */,
450     96 /* output pixel stride */,
451     w71.data(), w72.data(),
452     0.0f /* output min */, 6.0f /* output max */,
453     0 /* flags */,
454     &op3);
455   if (status != xnn_status_success) {
456     std::cerr << "failed to create operation #3" << std::endl;
457     return ExecutionPlan();
458   }
459   operators.emplace_back(op3, xnn_delete_operator);
460 
461   xnn_operator_t op4 = nullptr;
462   status = xnn_create_convolution2d_nhwc_f16(
463     0 /* top padding */, 1 /* right padding */,
464     1 /* bottom padding */, 0 /* left padding */,
465     3 /* kernel height */, 3 /* kernel width */,
466     2 /* subsampling height */, 2 /* subsampling width */,
467     1 /* dilation_height */, 1 /* dilation_width */,
468     96 /* groups */,
469     1 /* input channels per group */,
470     1 /* output_channels_per_group */,
471     96 /* input pixel stride */,
472     96 /* output pixel stride */,
473     w73.data(), w74.data(),
474     0.0f /* output min */, 6.0f /* output max */,
475     0 /* flags */,
476     &op4);
477   if (status != xnn_status_success) {
478     std::cerr << "failed to create operation #4" << std::endl;
479     return ExecutionPlan();
480   }
481   operators.emplace_back(op4, xnn_delete_operator);
482 
483   xnn_operator_t op5 = nullptr;
484   status = xnn_create_convolution2d_nhwc_f16(
485     0 /* top padding */, 0 /* right padding */,
486     0 /* bottom padding */, 0 /* left padding */,
487     1 /* kernel height */, 1 /* kernel width */,
488     1 /* subsampling height */, 1 /* subsampling width */,
489     1 /* dilation_height */, 1 /* dilation_width */,
490     1 /* groups */,
491     96 /* input channels per group */,
492     24 /* output_channels_per_group */,
493     96 /* input pixel stride */,
494     24 /* output pixel stride */,
495     w75.data(), w76.data(),
496     -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
497     0 /* flags */,
498     &op5);
499   if (status != xnn_status_success) {
500     std::cerr << "failed to create operation #5" << std::endl;
501     return ExecutionPlan();
502   }
503   operators.emplace_back(op5, xnn_delete_operator);
504 
505   xnn_operator_t op6 = nullptr;
506   status = xnn_create_convolution2d_nhwc_f16(
507     0 /* top padding */, 0 /* right padding */,
508     0 /* bottom padding */, 0 /* left padding */,
509     1 /* kernel height */, 1 /* kernel width */,
510     1 /* subsampling height */, 1 /* subsampling width */,
511     1 /* dilation_height */, 1 /* dilation_width */,
512     1 /* groups */,
513     24 /* input channels per group */,
514     144 /* output_channels_per_group */,
515     24 /* input pixel stride */,
516     144 /* output pixel stride */,
517     w77.data(), w78.data(),
518     0.0f /* output min */, 6.0f /* output max */,
519     0 /* flags */,
520     &op6);
521   if (status != xnn_status_success) {
522     std::cerr << "failed to create operation #6" << std::endl;
523     return ExecutionPlan();
524   }
525   operators.emplace_back(op6, xnn_delete_operator);
526 
527   xnn_operator_t op7 = nullptr;
528   status = xnn_create_convolution2d_nhwc_f16(
529     1 /* top padding */, 1 /* right padding */,
530     1 /* bottom padding */, 1 /* left padding */,
531     3 /* kernel height */, 3 /* kernel width */,
532     1 /* subsampling height */, 1 /* subsampling width */,
533     1 /* dilation_height */, 1 /* dilation_width */,
534     144 /* groups */,
535     1 /* input channels per group */,
536     1 /* output_channels_per_group */,
537     144 /* input pixel stride */,
538     144 /* output pixel stride */,
539     w79.data(), w80.data(),
540     0.0f /* output min */, 6.0f /* output max */,
541     0 /* flags */,
542     &op7);
543   if (status != xnn_status_success) {
544     std::cerr << "failed to create operation #7" << std::endl;
545     return ExecutionPlan();
546   }
547   operators.emplace_back(op7, xnn_delete_operator);
548 
549   xnn_operator_t op8 = nullptr;
550   status = xnn_create_convolution2d_nhwc_f16(
551     0 /* top padding */, 0 /* right padding */,
552     0 /* bottom padding */, 0 /* left padding */,
553     1 /* kernel height */, 1 /* kernel width */,
554     1 /* subsampling height */, 1 /* subsampling width */,
555     1 /* dilation_height */, 1 /* dilation_width */,
556     1 /* groups */,
557     144 /* input channels per group */,
558     24 /* output_channels_per_group */,
559     144 /* input pixel stride */,
560     24 /* output pixel stride */,
561     w81.data(), w82.data(),
562     -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
563     0 /* flags */,
564     &op8);
565   if (status != xnn_status_success) {
566     std::cerr << "failed to create operation #8" << std::endl;
567     return ExecutionPlan();
568   }
569   operators.emplace_back(op8, xnn_delete_operator);
570 
571   xnn_operator_t op9 = nullptr;
572   status = xnn_create_add_nd_f16(
573     -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
574     0 /* flags */,
575     &op9);
576   if (status != xnn_status_success) {
577     std::cerr << "failed to create operation #9" << std::endl;
578     return ExecutionPlan();
579   }
580   operators.emplace_back(op9, xnn_delete_operator);
581 
582   xnn_operator_t op10 = 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     24 /* input channels per group */,
591     144 /* output_channels_per_group */,
592     24 /* input pixel stride */,
593     144 /* output pixel stride */,
594     w83.data(), w84.data(),
595     0.0f /* output min */, 6.0f /* output max */,
596     0 /* flags */,
597     &op10);
598   if (status != xnn_status_success) {
599     std::cerr << "failed to create operation #10" << std::endl;
600     return ExecutionPlan();
601   }
602   operators.emplace_back(op10, xnn_delete_operator);
603 
604   xnn_operator_t op11 = nullptr;
605   status = xnn_create_convolution2d_nhwc_f16(
606     0 /* top padding */, 1 /* right padding */,
607     1 /* bottom padding */, 0 /* left padding */,
608     3 /* kernel height */, 3 /* kernel width */,
609     2 /* subsampling height */, 2 /* subsampling width */,
610     1 /* dilation_height */, 1 /* dilation_width */,
611     144 /* groups */,
612     1 /* input channels per group */,
613     1 /* output_channels_per_group */,
614     144 /* input pixel stride */,
615     144 /* output pixel stride */,
616     w85.data(), w86.data(),
617     0.0f /* output min */, 6.0f /* output max */,
618     0 /* flags */,
619     &op11);
620   if (status != xnn_status_success) {
621     std::cerr << "failed to create operation #11" << std::endl;
622     return ExecutionPlan();
623   }
624   operators.emplace_back(op11, xnn_delete_operator);
625 
626   xnn_operator_t op12 = nullptr;
627   status = xnn_create_convolution2d_nhwc_f16(
628     0 /* top padding */, 0 /* right padding */,
629     0 /* bottom padding */, 0 /* left padding */,
630     1 /* kernel height */, 1 /* kernel width */,
631     1 /* subsampling height */, 1 /* subsampling width */,
632     1 /* dilation_height */, 1 /* dilation_width */,
633     1 /* groups */,
634     144 /* input channels per group */,
635     32 /* output_channels_per_group */,
636     144 /* input pixel stride */,
637     32 /* output pixel stride */,
638     w87.data(), w88.data(),
639     -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
640     0 /* flags */,
641     &op12);
642   if (status != xnn_status_success) {
643     std::cerr << "failed to create operation #12" << std::endl;
644     return ExecutionPlan();
645   }
646   operators.emplace_back(op12, xnn_delete_operator);
647 
648   xnn_operator_t op13 = nullptr;
649   status = xnn_create_convolution2d_nhwc_f16(
650     0 /* top padding */, 0 /* right padding */,
651     0 /* bottom padding */, 0 /* left padding */,
652     1 /* kernel height */, 1 /* kernel width */,
653     1 /* subsampling height */, 1 /* subsampling width */,
654     1 /* dilation_height */, 1 /* dilation_width */,
655     1 /* groups */,
656     32 /* input channels per group */,
657     192 /* output_channels_per_group */,
658     32 /* input pixel stride */,
659     192 /* output pixel stride */,
660     w89.data(), w90.data(),
661     0.0f /* output min */, 6.0f /* output max */,
662     0 /* flags */,
663     &op13);
664   if (status != xnn_status_success) {
665     std::cerr << "failed to create operation #13" << std::endl;
666     return ExecutionPlan();
667   }
668   operators.emplace_back(op13, xnn_delete_operator);
669 
670   xnn_operator_t op14 = nullptr;
671   status = xnn_create_convolution2d_nhwc_f16(
672     1 /* top padding */, 1 /* right padding */,
673     1 /* bottom padding */, 1 /* left padding */,
674     3 /* kernel height */, 3 /* kernel width */,
675     1 /* subsampling height */, 1 /* subsampling width */,
676     1 /* dilation_height */, 1 /* dilation_width */,
677     192 /* groups */,
678     1 /* input channels per group */,
679     1 /* output_channels_per_group */,
680     192 /* input pixel stride */,
681     192 /* output pixel stride */,
682     w91.data(), w92.data(),
683     0.0f /* output min */, 6.0f /* output max */,
684     0 /* flags */,
685     &op14);
686   if (status != xnn_status_success) {
687     std::cerr << "failed to create operation #14" << std::endl;
688     return ExecutionPlan();
689   }
690   operators.emplace_back(op14, xnn_delete_operator);
691 
692   xnn_operator_t op15 = nullptr;
693   status = xnn_create_convolution2d_nhwc_f16(
694     0 /* top padding */, 0 /* right padding */,
695     0 /* bottom padding */, 0 /* left padding */,
696     1 /* kernel height */, 1 /* kernel width */,
697     1 /* subsampling height */, 1 /* subsampling width */,
698     1 /* dilation_height */, 1 /* dilation_width */,
699     1 /* groups */,
700     192 /* input channels per group */,
701     32 /* output_channels_per_group */,
702     192 /* input pixel stride */,
703     32 /* output pixel stride */,
704     w93.data(), w94.data(),
705     -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
706     0 /* flags */,
707     &op15);
708   if (status != xnn_status_success) {
709     std::cerr << "failed to create operation #15" << std::endl;
710     return ExecutionPlan();
711   }
712   operators.emplace_back(op15, xnn_delete_operator);
713 
714   xnn_operator_t op16 = nullptr;
715   status = xnn_create_add_nd_f16(
716     -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
717     0 /* flags */,
718     &op16);
719   if (status != xnn_status_success) {
720     std::cerr << "failed to create operation #16" << std::endl;
721     return ExecutionPlan();
722   }
723   operators.emplace_back(op16, xnn_delete_operator);
724 
725   xnn_operator_t op17 = nullptr;
726   status = xnn_create_convolution2d_nhwc_f16(
727     0 /* top padding */, 0 /* right padding */,
728     0 /* bottom padding */, 0 /* left padding */,
729     1 /* kernel height */, 1 /* kernel width */,
730     1 /* subsampling height */, 1 /* subsampling width */,
731     1 /* dilation_height */, 1 /* dilation_width */,
732     1 /* groups */,
733     32 /* input channels per group */,
734     192 /* output_channels_per_group */,
735     32 /* input pixel stride */,
736     192 /* output pixel stride */,
737     w95.data(), w96.data(),
738     0.0f /* output min */, 6.0f /* output max */,
739     0 /* flags */,
740     &op17);
741   if (status != xnn_status_success) {
742     std::cerr << "failed to create operation #17" << std::endl;
743     return ExecutionPlan();
744   }
745   operators.emplace_back(op17, xnn_delete_operator);
746 
747   xnn_operator_t op18 = nullptr;
748   status = xnn_create_convolution2d_nhwc_f16(
749     1 /* top padding */, 1 /* right padding */,
750     1 /* bottom padding */, 1 /* left padding */,
751     3 /* kernel height */, 3 /* kernel width */,
752     1 /* subsampling height */, 1 /* subsampling width */,
753     1 /* dilation_height */, 1 /* dilation_width */,
754     192 /* groups */,
755     1 /* input channels per group */,
756     1 /* output_channels_per_group */,
757     192 /* input pixel stride */,
758     192 /* output pixel stride */,
759     w97.data(), w98.data(),
760     0.0f /* output min */, 6.0f /* output max */,
761     0 /* flags */,
762     &op18);
763   if (status != xnn_status_success) {
764     std::cerr << "failed to create operation #18" << std::endl;
765     return ExecutionPlan();
766   }
767   operators.emplace_back(op18, xnn_delete_operator);
768 
769   xnn_operator_t op19 = nullptr;
770   status = xnn_create_convolution2d_nhwc_f16(
771     0 /* top padding */, 0 /* right padding */,
772     0 /* bottom padding */, 0 /* left padding */,
773     1 /* kernel height */, 1 /* kernel width */,
774     1 /* subsampling height */, 1 /* subsampling width */,
775     1 /* dilation_height */, 1 /* dilation_width */,
776     1 /* groups */,
777     192 /* input channels per group */,
778     32 /* output_channels_per_group */,
779     192 /* input pixel stride */,
780     32 /* output pixel stride */,
781     w99.data(), w100.data(),
782     -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
783     0 /* flags */,
784     &op19);
785   if (status != xnn_status_success) {
786     std::cerr << "failed to create operation #19" << std::endl;
787     return ExecutionPlan();
788   }
789   operators.emplace_back(op19, xnn_delete_operator);
790 
791   xnn_operator_t op20 = nullptr;
792   status = xnn_create_add_nd_f16(
793     -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
794     0 /* flags */,
795     &op20);
796   if (status != xnn_status_success) {
797     std::cerr << "failed to create operation #20" << std::endl;
798     return ExecutionPlan();
799   }
800   operators.emplace_back(op20, xnn_delete_operator);
801 
802   xnn_operator_t op21 = nullptr;
803   status = xnn_create_convolution2d_nhwc_f16(
804     0 /* top padding */, 0 /* right padding */,
805     0 /* bottom padding */, 0 /* left padding */,
806     1 /* kernel height */, 1 /* kernel width */,
807     1 /* subsampling height */, 1 /* subsampling width */,
808     1 /* dilation_height */, 1 /* dilation_width */,
809     1 /* groups */,
810     32 /* input channels per group */,
811     192 /* output_channels_per_group */,
812     32 /* input pixel stride */,
813     192 /* output pixel stride */,
814     w101.data(), w102.data(),
815     0.0f /* output min */, 6.0f /* output max */,
816     0 /* flags */,
817     &op21);
818   if (status != xnn_status_success) {
819     std::cerr << "failed to create operation #21" << std::endl;
820     return ExecutionPlan();
821   }
822   operators.emplace_back(op21, xnn_delete_operator);
823 
824   xnn_operator_t op22 = nullptr;
825   status = xnn_create_convolution2d_nhwc_f16(
826     0 /* top padding */, 1 /* right padding */,
827     1 /* bottom padding */, 0 /* left padding */,
828     3 /* kernel height */, 3 /* kernel width */,
829     2 /* subsampling height */, 2 /* subsampling width */,
830     1 /* dilation_height */, 1 /* dilation_width */,
831     192 /* groups */,
832     1 /* input channels per group */,
833     1 /* output_channels_per_group */,
834     192 /* input pixel stride */,
835     192 /* output pixel stride */,
836     w103.data(), w104.data(),
837     0.0f /* output min */, 6.0f /* output max */,
838     0 /* flags */,
839     &op22);
840   if (status != xnn_status_success) {
841     std::cerr << "failed to create operation #22" << std::endl;
842     return ExecutionPlan();
843   }
844   operators.emplace_back(op22, xnn_delete_operator);
845 
846   xnn_operator_t op23 = 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     192 /* input channels per group */,
855     64 /* output_channels_per_group */,
856     192 /* input pixel stride */,
857     64 /* output pixel stride */,
858     w105.data(), w106.data(),
859     -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
860     0 /* flags */,
861     &op23);
862   if (status != xnn_status_success) {
863     std::cerr << "failed to create operation #23" << std::endl;
864     return ExecutionPlan();
865   }
866   operators.emplace_back(op23, xnn_delete_operator);
867 
868   xnn_operator_t op24 = nullptr;
869   status = xnn_create_convolution2d_nhwc_f16(
870     0 /* top padding */, 0 /* right padding */,
871     0 /* bottom padding */, 0 /* left padding */,
872     1 /* kernel height */, 1 /* kernel width */,
873     1 /* subsampling height */, 1 /* subsampling width */,
874     1 /* dilation_height */, 1 /* dilation_width */,
875     1 /* groups */,
876     64 /* input channels per group */,
877     384 /* output_channels_per_group */,
878     64 /* input pixel stride */,
879     384 /* output pixel stride */,
880     w107.data(), w108.data(),
881     0.0f /* output min */, 6.0f /* output max */,
882     0 /* flags */,
883     &op24);
884   if (status != xnn_status_success) {
885     std::cerr << "failed to create operation #24" << std::endl;
886     return ExecutionPlan();
887   }
888   operators.emplace_back(op24, xnn_delete_operator);
889 
890   xnn_operator_t op25 = nullptr;
891   status = xnn_create_convolution2d_nhwc_f16(
892     1 /* top padding */, 1 /* right padding */,
893     1 /* bottom padding */, 1 /* left padding */,
894     3 /* kernel height */, 3 /* kernel width */,
895     1 /* subsampling height */, 1 /* subsampling width */,
896     1 /* dilation_height */, 1 /* dilation_width */,
897     384 /* groups */,
898     1 /* input channels per group */,
899     1 /* output_channels_per_group */,
900     384 /* input pixel stride */,
901     384 /* output pixel stride */,
902     w109.data(), w110.data(),
903     0.0f /* output min */, 6.0f /* output max */,
904     0 /* flags */,
905     &op25);
906   if (status != xnn_status_success) {
907     std::cerr << "failed to create operation #25" << std::endl;
908     return ExecutionPlan();
909   }
910   operators.emplace_back(op25, xnn_delete_operator);
911 
912   xnn_operator_t op26 = nullptr;
913   status = xnn_create_convolution2d_nhwc_f16(
914     0 /* top padding */, 0 /* right padding */,
915     0 /* bottom padding */, 0 /* left padding */,
916     1 /* kernel height */, 1 /* kernel width */,
917     1 /* subsampling height */, 1 /* subsampling width */,
918     1 /* dilation_height */, 1 /* dilation_width */,
919     1 /* groups */,
920     384 /* input channels per group */,
921     64 /* output_channels_per_group */,
922     384 /* input pixel stride */,
923     64 /* output pixel stride */,
924     w111.data(), w112.data(),
925     -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
926     0 /* flags */,
927     &op26);
928   if (status != xnn_status_success) {
929     std::cerr << "failed to create operation #26" << std::endl;
930     return ExecutionPlan();
931   }
932   operators.emplace_back(op26, xnn_delete_operator);
933 
934   xnn_operator_t op27 = nullptr;
935   status = xnn_create_add_nd_f16(
936     -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
937     0 /* flags */,
938     &op27);
939   if (status != xnn_status_success) {
940     std::cerr << "failed to create operation #27" << std::endl;
941     return ExecutionPlan();
942   }
943   operators.emplace_back(op27, xnn_delete_operator);
944 
945   xnn_operator_t op28 = nullptr;
946   status = xnn_create_convolution2d_nhwc_f16(
947     0 /* top padding */, 0 /* right padding */,
948     0 /* bottom padding */, 0 /* left padding */,
949     1 /* kernel height */, 1 /* kernel width */,
950     1 /* subsampling height */, 1 /* subsampling width */,
951     1 /* dilation_height */, 1 /* dilation_width */,
952     1 /* groups */,
953     64 /* input channels per group */,
954     384 /* output_channels_per_group */,
955     64 /* input pixel stride */,
956     384 /* output pixel stride */,
957     w113.data(), w114.data(),
958     0.0f /* output min */, 6.0f /* output max */,
959     0 /* flags */,
960     &op28);
961   if (status != xnn_status_success) {
962     std::cerr << "failed to create operation #28" << std::endl;
963     return ExecutionPlan();
964   }
965   operators.emplace_back(op28, xnn_delete_operator);
966 
967   xnn_operator_t op29 = nullptr;
968   status = xnn_create_convolution2d_nhwc_f16(
969     1 /* top padding */, 1 /* right padding */,
970     1 /* bottom padding */, 1 /* left padding */,
971     3 /* kernel height */, 3 /* kernel width */,
972     1 /* subsampling height */, 1 /* subsampling width */,
973     1 /* dilation_height */, 1 /* dilation_width */,
974     384 /* groups */,
975     1 /* input channels per group */,
976     1 /* output_channels_per_group */,
977     384 /* input pixel stride */,
978     384 /* output pixel stride */,
979     w115.data(), w116.data(),
980     0.0f /* output min */, 6.0f /* output max */,
981     0 /* flags */,
982     &op29);
983   if (status != xnn_status_success) {
984     std::cerr << "failed to create operation #29" << std::endl;
985     return ExecutionPlan();
986   }
987   operators.emplace_back(op29, xnn_delete_operator);
988 
989   xnn_operator_t op30 = nullptr;
990   status = xnn_create_convolution2d_nhwc_f16(
991     0 /* top padding */, 0 /* right padding */,
992     0 /* bottom padding */, 0 /* left padding */,
993     1 /* kernel height */, 1 /* kernel width */,
994     1 /* subsampling height */, 1 /* subsampling width */,
995     1 /* dilation_height */, 1 /* dilation_width */,
996     1 /* groups */,
997     384 /* input channels per group */,
998     64 /* output_channels_per_group */,
999     384 /* input pixel stride */,
1000     64 /* output pixel stride */,
1001     w117.data(), w118.data(),
1002     -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1003     0 /* flags */,
1004     &op30);
1005   if (status != xnn_status_success) {
1006     std::cerr << "failed to create operation #30" << std::endl;
1007     return ExecutionPlan();
1008   }
1009   operators.emplace_back(op30, xnn_delete_operator);
1010 
1011   xnn_operator_t op31 = nullptr;
1012   status = xnn_create_add_nd_f16(
1013     -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1014     0 /* flags */,
1015     &op31);
1016   if (status != xnn_status_success) {
1017     std::cerr << "failed to create operation #31" << std::endl;
1018     return ExecutionPlan();
1019   }
1020   operators.emplace_back(op31, xnn_delete_operator);
1021 
1022   xnn_operator_t op32 = nullptr;
1023   status = xnn_create_convolution2d_nhwc_f16(
1024     0 /* top padding */, 0 /* right padding */,
1025     0 /* bottom padding */, 0 /* left padding */,
1026     1 /* kernel height */, 1 /* kernel width */,
1027     1 /* subsampling height */, 1 /* subsampling width */,
1028     1 /* dilation_height */, 1 /* dilation_width */,
1029     1 /* groups */,
1030     64 /* input channels per group */,
1031     384 /* output_channels_per_group */,
1032     64 /* input pixel stride */,
1033     384 /* output pixel stride */,
1034     w119.data(), w120.data(),
1035     0.0f /* output min */, 6.0f /* output max */,
1036     0 /* flags */,
1037     &op32);
1038   if (status != xnn_status_success) {
1039     std::cerr << "failed to create operation #32" << std::endl;
1040     return ExecutionPlan();
1041   }
1042   operators.emplace_back(op32, xnn_delete_operator);
1043 
1044   xnn_operator_t op33 = nullptr;
1045   status = xnn_create_convolution2d_nhwc_f16(
1046     1 /* top padding */, 1 /* right padding */,
1047     1 /* bottom padding */, 1 /* left padding */,
1048     3 /* kernel height */, 3 /* kernel width */,
1049     1 /* subsampling height */, 1 /* subsampling width */,
1050     1 /* dilation_height */, 1 /* dilation_width */,
1051     384 /* groups */,
1052     1 /* input channels per group */,
1053     1 /* output_channels_per_group */,
1054     384 /* input pixel stride */,
1055     384 /* output pixel stride */,
1056     w121.data(), w122.data(),
1057     0.0f /* output min */, 6.0f /* output max */,
1058     0 /* flags */,
1059     &op33);
1060   if (status != xnn_status_success) {
1061     std::cerr << "failed to create operation #33" << std::endl;
1062     return ExecutionPlan();
1063   }
1064   operators.emplace_back(op33, xnn_delete_operator);
1065 
1066   xnn_operator_t op34 = nullptr;
1067   status = xnn_create_convolution2d_nhwc_f16(
1068     0 /* top padding */, 0 /* right padding */,
1069     0 /* bottom padding */, 0 /* left padding */,
1070     1 /* kernel height */, 1 /* kernel width */,
1071     1 /* subsampling height */, 1 /* subsampling width */,
1072     1 /* dilation_height */, 1 /* dilation_width */,
1073     1 /* groups */,
1074     384 /* input channels per group */,
1075     64 /* output_channels_per_group */,
1076     384 /* input pixel stride */,
1077     64 /* output pixel stride */,
1078     w123.data(), w124.data(),
1079     -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1080     0 /* flags */,
1081     &op34);
1082   if (status != xnn_status_success) {
1083     std::cerr << "failed to create operation #34" << std::endl;
1084     return ExecutionPlan();
1085   }
1086   operators.emplace_back(op34, xnn_delete_operator);
1087 
1088   xnn_operator_t op35 = nullptr;
1089   status = xnn_create_add_nd_f16(
1090     -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1091     0 /* flags */,
1092     &op35);
1093   if (status != xnn_status_success) {
1094     std::cerr << "failed to create operation #35" << std::endl;
1095     return ExecutionPlan();
1096   }
1097   operators.emplace_back(op35, xnn_delete_operator);
1098 
1099   xnn_operator_t op36 = nullptr;
1100   status = xnn_create_convolution2d_nhwc_f16(
1101     0 /* top padding */, 0 /* right padding */,
1102     0 /* bottom padding */, 0 /* left padding */,
1103     1 /* kernel height */, 1 /* kernel width */,
1104     1 /* subsampling height */, 1 /* subsampling width */,
1105     1 /* dilation_height */, 1 /* dilation_width */,
1106     1 /* groups */,
1107     64 /* input channels per group */,
1108     384 /* output_channels_per_group */,
1109     64 /* input pixel stride */,
1110     384 /* output pixel stride */,
1111     w125.data(), w126.data(),
1112     0.0f /* output min */, 6.0f /* output max */,
1113     0 /* flags */,
1114     &op36);
1115   if (status != xnn_status_success) {
1116     std::cerr << "failed to create operation #36" << std::endl;
1117     return ExecutionPlan();
1118   }
1119   operators.emplace_back(op36, xnn_delete_operator);
1120 
1121   xnn_operator_t op37 = nullptr;
1122   status = xnn_create_convolution2d_nhwc_f16(
1123     1 /* top padding */, 1 /* right padding */,
1124     1 /* bottom padding */, 1 /* left padding */,
1125     3 /* kernel height */, 3 /* kernel width */,
1126     1 /* subsampling height */, 1 /* subsampling width */,
1127     1 /* dilation_height */, 1 /* dilation_width */,
1128     384 /* groups */,
1129     1 /* input channels per group */,
1130     1 /* output_channels_per_group */,
1131     384 /* input pixel stride */,
1132     384 /* output pixel stride */,
1133     w127.data(), w128.data(),
1134     0.0f /* output min */, 6.0f /* output max */,
1135     0 /* flags */,
1136     &op37);
1137   if (status != xnn_status_success) {
1138     std::cerr << "failed to create operation #37" << std::endl;
1139     return ExecutionPlan();
1140   }
1141   operators.emplace_back(op37, xnn_delete_operator);
1142 
1143   xnn_operator_t op38 = nullptr;
1144   status = xnn_create_convolution2d_nhwc_f16(
1145     0 /* top padding */, 0 /* right padding */,
1146     0 /* bottom padding */, 0 /* left padding */,
1147     1 /* kernel height */, 1 /* kernel width */,
1148     1 /* subsampling height */, 1 /* subsampling width */,
1149     1 /* dilation_height */, 1 /* dilation_width */,
1150     1 /* groups */,
1151     384 /* input channels per group */,
1152     96 /* output_channels_per_group */,
1153     384 /* input pixel stride */,
1154     96 /* output pixel stride */,
1155     w129.data(), w130.data(),
1156     -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1157     0 /* flags */,
1158     &op38);
1159   if (status != xnn_status_success) {
1160     std::cerr << "failed to create operation #38" << std::endl;
1161     return ExecutionPlan();
1162   }
1163   operators.emplace_back(op38, xnn_delete_operator);
1164 
1165   xnn_operator_t op39 = nullptr;
1166   status = xnn_create_convolution2d_nhwc_f16(
1167     0 /* top padding */, 0 /* right padding */,
1168     0 /* bottom padding */, 0 /* left padding */,
1169     1 /* kernel height */, 1 /* kernel width */,
1170     1 /* subsampling height */, 1 /* subsampling width */,
1171     1 /* dilation_height */, 1 /* dilation_width */,
1172     1 /* groups */,
1173     96 /* input channels per group */,
1174     576 /* output_channels_per_group */,
1175     96 /* input pixel stride */,
1176     576 /* output pixel stride */,
1177     w131.data(), w132.data(),
1178     0.0f /* output min */, 6.0f /* output max */,
1179     0 /* flags */,
1180     &op39);
1181   if (status != xnn_status_success) {
1182     std::cerr << "failed to create operation #39" << std::endl;
1183     return ExecutionPlan();
1184   }
1185   operators.emplace_back(op39, xnn_delete_operator);
1186 
1187   xnn_operator_t op40 = nullptr;
1188   status = xnn_create_convolution2d_nhwc_f16(
1189     1 /* top padding */, 1 /* right padding */,
1190     1 /* bottom padding */, 1 /* left padding */,
1191     3 /* kernel height */, 3 /* kernel width */,
1192     1 /* subsampling height */, 1 /* subsampling width */,
1193     1 /* dilation_height */, 1 /* dilation_width */,
1194     576 /* groups */,
1195     1 /* input channels per group */,
1196     1 /* output_channels_per_group */,
1197     576 /* input pixel stride */,
1198     576 /* output pixel stride */,
1199     w133.data(), w134.data(),
1200     0.0f /* output min */, 6.0f /* output max */,
1201     0 /* flags */,
1202     &op40);
1203   if (status != xnn_status_success) {
1204     std::cerr << "failed to create operation #40" << std::endl;
1205     return ExecutionPlan();
1206   }
1207   operators.emplace_back(op40, xnn_delete_operator);
1208 
1209   xnn_operator_t op41 = nullptr;
1210   status = xnn_create_convolution2d_nhwc_f16(
1211     0 /* top padding */, 0 /* right padding */,
1212     0 /* bottom padding */, 0 /* left padding */,
1213     1 /* kernel height */, 1 /* kernel width */,
1214     1 /* subsampling height */, 1 /* subsampling width */,
1215     1 /* dilation_height */, 1 /* dilation_width */,
1216     1 /* groups */,
1217     576 /* input channels per group */,
1218     96 /* output_channels_per_group */,
1219     576 /* input pixel stride */,
1220     96 /* output pixel stride */,
1221     w135.data(), w136.data(),
1222     -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1223     0 /* flags */,
1224     &op41);
1225   if (status != xnn_status_success) {
1226     std::cerr << "failed to create operation #41" << std::endl;
1227     return ExecutionPlan();
1228   }
1229   operators.emplace_back(op41, xnn_delete_operator);
1230 
1231   xnn_operator_t op42 = nullptr;
1232   status = xnn_create_add_nd_f16(
1233     -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1234     0 /* flags */,
1235     &op42);
1236   if (status != xnn_status_success) {
1237     std::cerr << "failed to create operation #42" << std::endl;
1238     return ExecutionPlan();
1239   }
1240   operators.emplace_back(op42, xnn_delete_operator);
1241 
1242   xnn_operator_t op43 = nullptr;
1243   status = xnn_create_convolution2d_nhwc_f16(
1244     0 /* top padding */, 0 /* right padding */,
1245     0 /* bottom padding */, 0 /* left padding */,
1246     1 /* kernel height */, 1 /* kernel width */,
1247     1 /* subsampling height */, 1 /* subsampling width */,
1248     1 /* dilation_height */, 1 /* dilation_width */,
1249     1 /* groups */,
1250     96 /* input channels per group */,
1251     576 /* output_channels_per_group */,
1252     96 /* input pixel stride */,
1253     576 /* output pixel stride */,
1254     w137.data(), w138.data(),
1255     0.0f /* output min */, 6.0f /* output max */,
1256     0 /* flags */,
1257     &op43);
1258   if (status != xnn_status_success) {
1259     std::cerr << "failed to create operation #43" << std::endl;
1260     return ExecutionPlan();
1261   }
1262   operators.emplace_back(op43, xnn_delete_operator);
1263 
1264   xnn_operator_t op44 = nullptr;
1265   status = xnn_create_convolution2d_nhwc_f16(
1266     1 /* top padding */, 1 /* right padding */,
1267     1 /* bottom padding */, 1 /* left padding */,
1268     3 /* kernel height */, 3 /* kernel width */,
1269     1 /* subsampling height */, 1 /* subsampling width */,
1270     1 /* dilation_height */, 1 /* dilation_width */,
1271     576 /* groups */,
1272     1 /* input channels per group */,
1273     1 /* output_channels_per_group */,
1274     576 /* input pixel stride */,
1275     576 /* output pixel stride */,
1276     w139.data(), w140.data(),
1277     0.0f /* output min */, 6.0f /* output max */,
1278     0 /* flags */,
1279     &op44);
1280   if (status != xnn_status_success) {
1281     std::cerr << "failed to create operation #44" << std::endl;
1282     return ExecutionPlan();
1283   }
1284   operators.emplace_back(op44, xnn_delete_operator);
1285 
1286   xnn_operator_t op45 = nullptr;
1287   status = xnn_create_convolution2d_nhwc_f16(
1288     0 /* top padding */, 0 /* right padding */,
1289     0 /* bottom padding */, 0 /* left padding */,
1290     1 /* kernel height */, 1 /* kernel width */,
1291     1 /* subsampling height */, 1 /* subsampling width */,
1292     1 /* dilation_height */, 1 /* dilation_width */,
1293     1 /* groups */,
1294     576 /* input channels per group */,
1295     96 /* output_channels_per_group */,
1296     576 /* input pixel stride */,
1297     96 /* output pixel stride */,
1298     w141.data(), w142.data(),
1299     -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1300     0 /* flags */,
1301     &op45);
1302   if (status != xnn_status_success) {
1303     std::cerr << "failed to create operation #45" << std::endl;
1304     return ExecutionPlan();
1305   }
1306   operators.emplace_back(op45, xnn_delete_operator);
1307 
1308   xnn_operator_t op46 = nullptr;
1309   status = xnn_create_add_nd_f16(
1310     -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1311     0 /* flags */,
1312     &op46);
1313   if (status != xnn_status_success) {
1314     std::cerr << "failed to create operation #46" << std::endl;
1315     return ExecutionPlan();
1316   }
1317   operators.emplace_back(op46, xnn_delete_operator);
1318 
1319   xnn_operator_t op47 = nullptr;
1320   status = xnn_create_convolution2d_nhwc_f16(
1321     0 /* top padding */, 0 /* right padding */,
1322     0 /* bottom padding */, 0 /* left padding */,
1323     1 /* kernel height */, 1 /* kernel width */,
1324     1 /* subsampling height */, 1 /* subsampling width */,
1325     1 /* dilation_height */, 1 /* dilation_width */,
1326     1 /* groups */,
1327     96 /* input channels per group */,
1328     576 /* output_channels_per_group */,
1329     96 /* input pixel stride */,
1330     576 /* output pixel stride */,
1331     w143.data(), w144.data(),
1332     0.0f /* output min */, 6.0f /* output max */,
1333     0 /* flags */,
1334     &op47);
1335   if (status != xnn_status_success) {
1336     std::cerr << "failed to create operation #47" << std::endl;
1337     return ExecutionPlan();
1338   }
1339   operators.emplace_back(op47, xnn_delete_operator);
1340 
1341   xnn_operator_t op48 = nullptr;
1342   status = xnn_create_convolution2d_nhwc_f16(
1343     0 /* top padding */, 1 /* right padding */,
1344     1 /* bottom padding */, 0 /* left padding */,
1345     3 /* kernel height */, 3 /* kernel width */,
1346     2 /* subsampling height */, 2 /* subsampling width */,
1347     1 /* dilation_height */, 1 /* dilation_width */,
1348     576 /* groups */,
1349     1 /* input channels per group */,
1350     1 /* output_channels_per_group */,
1351     576 /* input pixel stride */,
1352     576 /* output pixel stride */,
1353     w145.data(), w146.data(),
1354     0.0f /* output min */, 6.0f /* output max */,
1355     0 /* flags */,
1356     &op48);
1357   if (status != xnn_status_success) {
1358     std::cerr << "failed to create operation #48" << std::endl;
1359     return ExecutionPlan();
1360   }
1361   operators.emplace_back(op48, xnn_delete_operator);
1362 
1363   xnn_operator_t op49 = nullptr;
1364   status = xnn_create_convolution2d_nhwc_f16(
1365     0 /* top padding */, 0 /* right padding */,
1366     0 /* bottom padding */, 0 /* left padding */,
1367     1 /* kernel height */, 1 /* kernel width */,
1368     1 /* subsampling height */, 1 /* subsampling width */,
1369     1 /* dilation_height */, 1 /* dilation_width */,
1370     1 /* groups */,
1371     576 /* input channels per group */,
1372     160 /* output_channels_per_group */,
1373     576 /* input pixel stride */,
1374     160 /* output pixel stride */,
1375     w147.data(), w148.data(),
1376     -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1377     0 /* flags */,
1378     &op49);
1379   if (status != xnn_status_success) {
1380     std::cerr << "failed to create operation #49" << std::endl;
1381     return ExecutionPlan();
1382   }
1383   operators.emplace_back(op49, xnn_delete_operator);
1384 
1385   xnn_operator_t op50 = nullptr;
1386   status = xnn_create_convolution2d_nhwc_f16(
1387     0 /* top padding */, 0 /* right padding */,
1388     0 /* bottom padding */, 0 /* left padding */,
1389     1 /* kernel height */, 1 /* kernel width */,
1390     1 /* subsampling height */, 1 /* subsampling width */,
1391     1 /* dilation_height */, 1 /* dilation_width */,
1392     1 /* groups */,
1393     160 /* input channels per group */,
1394     960 /* output_channels_per_group */,
1395     160 /* input pixel stride */,
1396     960 /* output pixel stride */,
1397     w149.data(), w150.data(),
1398     0.0f /* output min */, 6.0f /* output max */,
1399     0 /* flags */,
1400     &op50);
1401   if (status != xnn_status_success) {
1402     std::cerr << "failed to create operation #50" << std::endl;
1403     return ExecutionPlan();
1404   }
1405   operators.emplace_back(op50, xnn_delete_operator);
1406 
1407   xnn_operator_t op51 = nullptr;
1408   status = xnn_create_convolution2d_nhwc_f16(
1409     1 /* top padding */, 1 /* right padding */,
1410     1 /* bottom padding */, 1 /* left padding */,
1411     3 /* kernel height */, 3 /* kernel width */,
1412     1 /* subsampling height */, 1 /* subsampling width */,
1413     1 /* dilation_height */, 1 /* dilation_width */,
1414     960 /* groups */,
1415     1 /* input channels per group */,
1416     1 /* output_channels_per_group */,
1417     960 /* input pixel stride */,
1418     960 /* output pixel stride */,
1419     w151.data(), w152.data(),
1420     0.0f /* output min */, 6.0f /* output max */,
1421     0 /* flags */,
1422     &op51);
1423   if (status != xnn_status_success) {
1424     std::cerr << "failed to create operation #51" << std::endl;
1425     return ExecutionPlan();
1426   }
1427   operators.emplace_back(op51, xnn_delete_operator);
1428 
1429   xnn_operator_t op52 = nullptr;
1430   status = xnn_create_convolution2d_nhwc_f16(
1431     0 /* top padding */, 0 /* right padding */,
1432     0 /* bottom padding */, 0 /* left padding */,
1433     1 /* kernel height */, 1 /* kernel width */,
1434     1 /* subsampling height */, 1 /* subsampling width */,
1435     1 /* dilation_height */, 1 /* dilation_width */,
1436     1 /* groups */,
1437     960 /* input channels per group */,
1438     160 /* output_channels_per_group */,
1439     960 /* input pixel stride */,
1440     160 /* output pixel stride */,
1441     w153.data(), w154.data(),
1442     -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1443     0 /* flags */,
1444     &op52);
1445   if (status != xnn_status_success) {
1446     std::cerr << "failed to create operation #52" << std::endl;
1447     return ExecutionPlan();
1448   }
1449   operators.emplace_back(op52, xnn_delete_operator);
1450 
1451   xnn_operator_t op53 = nullptr;
1452   status = xnn_create_add_nd_f16(
1453     -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1454     0 /* flags */,
1455     &op53);
1456   if (status != xnn_status_success) {
1457     std::cerr << "failed to create operation #53" << std::endl;
1458     return ExecutionPlan();
1459   }
1460   operators.emplace_back(op53, xnn_delete_operator);
1461 
1462   xnn_operator_t op54 = nullptr;
1463   status = xnn_create_convolution2d_nhwc_f16(
1464     0 /* top padding */, 0 /* right padding */,
1465     0 /* bottom padding */, 0 /* left padding */,
1466     1 /* kernel height */, 1 /* kernel width */,
1467     1 /* subsampling height */, 1 /* subsampling width */,
1468     1 /* dilation_height */, 1 /* dilation_width */,
1469     1 /* groups */,
1470     160 /* input channels per group */,
1471     960 /* output_channels_per_group */,
1472     160 /* input pixel stride */,
1473     960 /* output pixel stride */,
1474     w155.data(), w156.data(),
1475     0.0f /* output min */, 6.0f /* output max */,
1476     0 /* flags */,
1477     &op54);
1478   if (status != xnn_status_success) {
1479     std::cerr << "failed to create operation #54" << std::endl;
1480     return ExecutionPlan();
1481   }
1482   operators.emplace_back(op54, xnn_delete_operator);
1483 
1484   xnn_operator_t op55 = nullptr;
1485   status = xnn_create_convolution2d_nhwc_f16(
1486     1 /* top padding */, 1 /* right padding */,
1487     1 /* bottom padding */, 1 /* left padding */,
1488     3 /* kernel height */, 3 /* kernel width */,
1489     1 /* subsampling height */, 1 /* subsampling width */,
1490     1 /* dilation_height */, 1 /* dilation_width */,
1491     960 /* groups */,
1492     1 /* input channels per group */,
1493     1 /* output_channels_per_group */,
1494     960 /* input pixel stride */,
1495     960 /* output pixel stride */,
1496     w157.data(), w158.data(),
1497     0.0f /* output min */, 6.0f /* output max */,
1498     0 /* flags */,
1499     &op55);
1500   if (status != xnn_status_success) {
1501     std::cerr << "failed to create operation #55" << std::endl;
1502     return ExecutionPlan();
1503   }
1504   operators.emplace_back(op55, xnn_delete_operator);
1505 
1506   xnn_operator_t op56 = nullptr;
1507   status = xnn_create_convolution2d_nhwc_f16(
1508     0 /* top padding */, 0 /* right padding */,
1509     0 /* bottom padding */, 0 /* left padding */,
1510     1 /* kernel height */, 1 /* kernel width */,
1511     1 /* subsampling height */, 1 /* subsampling width */,
1512     1 /* dilation_height */, 1 /* dilation_width */,
1513     1 /* groups */,
1514     960 /* input channels per group */,
1515     160 /* output_channels_per_group */,
1516     960 /* input pixel stride */,
1517     160 /* output pixel stride */,
1518     w159.data(), w160.data(),
1519     -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1520     0 /* flags */,
1521     &op56);
1522   if (status != xnn_status_success) {
1523     std::cerr << "failed to create operation #56" << std::endl;
1524     return ExecutionPlan();
1525   }
1526   operators.emplace_back(op56, xnn_delete_operator);
1527 
1528   xnn_operator_t op57 = nullptr;
1529   status = xnn_create_add_nd_f16(
1530     -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1531     0 /* flags */,
1532     &op57);
1533   if (status != xnn_status_success) {
1534     std::cerr << "failed to create operation #57" << std::endl;
1535     return ExecutionPlan();
1536   }
1537   operators.emplace_back(op57, xnn_delete_operator);
1538 
1539   xnn_operator_t op58 = nullptr;
1540   status = xnn_create_convolution2d_nhwc_f16(
1541     0 /* top padding */, 0 /* right padding */,
1542     0 /* bottom padding */, 0 /* left padding */,
1543     1 /* kernel height */, 1 /* kernel width */,
1544     1 /* subsampling height */, 1 /* subsampling width */,
1545     1 /* dilation_height */, 1 /* dilation_width */,
1546     1 /* groups */,
1547     160 /* input channels per group */,
1548     960 /* output_channels_per_group */,
1549     160 /* input pixel stride */,
1550     960 /* output pixel stride */,
1551     w161.data(), w162.data(),
1552     0.0f /* output min */, 6.0f /* output max */,
1553     0 /* flags */,
1554     &op58);
1555   if (status != xnn_status_success) {
1556     std::cerr << "failed to create operation #58" << std::endl;
1557     return ExecutionPlan();
1558   }
1559   operators.emplace_back(op58, xnn_delete_operator);
1560 
1561   xnn_operator_t op59 = nullptr;
1562   status = xnn_create_convolution2d_nhwc_f16(
1563     1 /* top padding */, 1 /* right padding */,
1564     1 /* bottom padding */, 1 /* left padding */,
1565     3 /* kernel height */, 3 /* kernel width */,
1566     1 /* subsampling height */, 1 /* subsampling width */,
1567     1 /* dilation_height */, 1 /* dilation_width */,
1568     960 /* groups */,
1569     1 /* input channels per group */,
1570     1 /* output_channels_per_group */,
1571     960 /* input pixel stride */,
1572     960 /* output pixel stride */,
1573     w163.data(), w164.data(),
1574     0.0f /* output min */, 6.0f /* output max */,
1575     0 /* flags */,
1576     &op59);
1577   if (status != xnn_status_success) {
1578     std::cerr << "failed to create operation #59" << std::endl;
1579     return ExecutionPlan();
1580   }
1581   operators.emplace_back(op59, xnn_delete_operator);
1582 
1583   xnn_operator_t op60 = nullptr;
1584   status = xnn_create_convolution2d_nhwc_f16(
1585     0 /* top padding */, 0 /* right padding */,
1586     0 /* bottom padding */, 0 /* left padding */,
1587     1 /* kernel height */, 1 /* kernel width */,
1588     1 /* subsampling height */, 1 /* subsampling width */,
1589     1 /* dilation_height */, 1 /* dilation_width */,
1590     1 /* groups */,
1591     960 /* input channels per group */,
1592     320 /* output_channels_per_group */,
1593     960 /* input pixel stride */,
1594     320 /* output pixel stride */,
1595     w165.data(), w166.data(),
1596     -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1597     0 /* flags */,
1598     &op60);
1599   if (status != xnn_status_success) {
1600     std::cerr << "failed to create operation #60" << std::endl;
1601     return ExecutionPlan();
1602   }
1603   operators.emplace_back(op60, xnn_delete_operator);
1604 
1605   xnn_operator_t op61 = nullptr;
1606   status = xnn_create_convolution2d_nhwc_f16(
1607     0 /* top padding */, 0 /* right padding */,
1608     0 /* bottom padding */, 0 /* left padding */,
1609     1 /* kernel height */, 1 /* kernel width */,
1610     1 /* subsampling height */, 1 /* subsampling width */,
1611     1 /* dilation_height */, 1 /* dilation_width */,
1612     1 /* groups */,
1613     320 /* input channels per group */,
1614     1280 /* output_channels_per_group */,
1615     320 /* input pixel stride */,
1616     1280 /* output pixel stride */,
1617     w167.data(), w168.data(),
1618     0.0f /* output min */, 6.0f /* output max */,
1619     0 /* flags */,
1620     &op61);
1621   if (status != xnn_status_success) {
1622     std::cerr << "failed to create operation #61" << std::endl;
1623     return ExecutionPlan();
1624   }
1625   operators.emplace_back(op61, xnn_delete_operator);
1626 
1627   xnn_operator_t op62 = nullptr;
1628   status = xnn_create_global_average_pooling_nwc_f16(
1629     1280 /* channels */, 1280 /* input stride */, 1280 /* output stride */,
1630     -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
1631     0 /* flags */,
1632     &op62);
1633   if (status != xnn_status_success) {
1634     std::cerr << "failed to create operation #62" << std::endl;
1635     return ExecutionPlan();
1636   }
1637   operators.emplace_back(op62, xnn_delete_operator);
1638 
1639   xnn_operator_t op63 = nullptr;
1640   status = xnn_create_convolution2d_nhwc_f16(
1641     0 /* top padding */, 0 /* right padding */,
1642     0 /* bottom padding */, 0 /* left padding */,
1643     1 /* kernel height */, 1 /* kernel width */,
1644     1 /* subsampling height */, 1 /* subsampling width */,
1645     1 /* dilation_height */, 1 /* dilation_width */,
1646     1 /* groups */,
1647     1280 /* input channels per group */,
1648     1001 /* output_channels_per_group */,
1649     1280 /* input pixel stride */,
1650     1001 /* output pixel stride */,
1651     w169.data(), w170.data(),
1652     -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1653     0 /* flags */,
1654     &op63);
1655   if (status != xnn_status_success) {
1656     std::cerr << "failed to create operation #63" << std::endl;
1657     return ExecutionPlan();
1658   }
1659   operators.emplace_back(op63, xnn_delete_operator);
1660 
1661 
1662 
1663   status = xnn_setup_convolution2d_nhwc_f16(
1664     op0,
1665     1 /* batch size */, 224 /* input height */, 224 /* input width */,
1666     v0.data() /* input */, v1.data() /* output */,
1667     threadpool /* threadpool */);
1668   if (status != xnn_status_success) {
1669     std::cerr << "failed to setup operation #0" << std::endl;
1670     return ExecutionPlan();
1671   }
1672 
1673   status = xnn_setup_convolution2d_nhwc_f16(
1674     op1,
1675     1 /* batch size */, 112 /* input height */, 112 /* input width */,
1676     v1.data() /* input */, v2.data() /* output */,
1677     threadpool /* threadpool */);
1678   if (status != xnn_status_success) {
1679     std::cerr << "failed to setup operation #1" << std::endl;
1680     return ExecutionPlan();
1681   }
1682 
1683   status = xnn_setup_convolution2d_nhwc_f16(
1684     op2,
1685     1 /* batch size */, 112 /* input height */, 112 /* input width */,
1686     v2.data() /* input */, v3.data() /* output */,
1687     threadpool /* threadpool */);
1688   if (status != xnn_status_success) {
1689     std::cerr << "failed to setup operation #2" << std::endl;
1690     return ExecutionPlan();
1691   }
1692 
1693   status = xnn_setup_convolution2d_nhwc_f16(
1694     op3,
1695     1 /* batch size */, 112 /* input height */, 112 /* input width */,
1696     v3.data() /* input */, v4.data() /* output */,
1697     threadpool /* threadpool */);
1698   if (status != xnn_status_success) {
1699     std::cerr << "failed to setup operation #3" << std::endl;
1700     return ExecutionPlan();
1701   }
1702 
1703   status = xnn_setup_convolution2d_nhwc_f16(
1704     op4,
1705     1 /* batch size */, 112 /* input height */, 112 /* input width */,
1706     v4.data() /* input */, v5.data() /* output */,
1707     threadpool /* threadpool */);
1708   if (status != xnn_status_success) {
1709     std::cerr << "failed to setup operation #4" << std::endl;
1710     return ExecutionPlan();
1711   }
1712 
1713   status = xnn_setup_convolution2d_nhwc_f16(
1714     op5,
1715     1 /* batch size */, 56 /* input height */, 56 /* input width */,
1716     v5.data() /* input */, v6.data() /* output */,
1717     threadpool /* threadpool */);
1718   if (status != xnn_status_success) {
1719     std::cerr << "failed to setup operation #5" << std::endl;
1720     return ExecutionPlan();
1721   }
1722 
1723   status = xnn_setup_convolution2d_nhwc_f16(
1724     op6,
1725     1 /* batch size */, 56 /* input height */, 56 /* input width */,
1726     v6.data() /* input */, v7.data() /* output */,
1727     threadpool /* threadpool */);
1728   if (status != xnn_status_success) {
1729     std::cerr << "failed to setup operation #6" << std::endl;
1730     return ExecutionPlan();
1731   }
1732 
1733   status = xnn_setup_convolution2d_nhwc_f16(
1734     op7,
1735     1 /* batch size */, 56 /* input height */, 56 /* input width */,
1736     v7.data() /* input */, v8.data() /* output */,
1737     threadpool /* threadpool */);
1738   if (status != xnn_status_success) {
1739     std::cerr << "failed to setup operation #7" << std::endl;
1740     return ExecutionPlan();
1741   }
1742 
1743   status = xnn_setup_convolution2d_nhwc_f16(
1744     op8,
1745     1 /* batch size */, 56 /* input height */, 56 /* input width */,
1746     v8.data() /* input */, v9.data() /* output */,
1747     threadpool /* threadpool */);
1748   if (status != xnn_status_success) {
1749     std::cerr << "failed to setup operation #8" << std::endl;
1750     return ExecutionPlan();
1751   }
1752 
1753   {
1754     const size_t a_shape[] = { 1, 56, 56, 24 };
1755     const size_t b_shape[] = { 1, 56, 56, 24 };
1756     status = xnn_setup_add_nd_f16(
1757       op9,
1758       4, a_shape, 4, b_shape,
1759       v9.data() /* a */, v6.data() /* b */, v10.data() /* output */,
1760       threadpool /* threadpool */);
1761   }
1762   if (status != xnn_status_success) {
1763     std::cerr << "failed to setup operation #9" << std::endl;
1764     return ExecutionPlan();
1765   }
1766 
1767   status = xnn_setup_convolution2d_nhwc_f16(
1768     op10,
1769     1 /* batch size */, 56 /* input height */, 56 /* input width */,
1770     v10.data() /* input */, v11.data() /* output */,
1771     threadpool /* threadpool */);
1772   if (status != xnn_status_success) {
1773     std::cerr << "failed to setup operation #10" << std::endl;
1774     return ExecutionPlan();
1775   }
1776 
1777   status = xnn_setup_convolution2d_nhwc_f16(
1778     op11,
1779     1 /* batch size */, 56 /* input height */, 56 /* input width */,
1780     v11.data() /* input */, v12.data() /* output */,
1781     threadpool /* threadpool */);
1782   if (status != xnn_status_success) {
1783     std::cerr << "failed to setup operation #11" << std::endl;
1784     return ExecutionPlan();
1785   }
1786 
1787   status = xnn_setup_convolution2d_nhwc_f16(
1788     op12,
1789     1 /* batch size */, 28 /* input height */, 28 /* input width */,
1790     v12.data() /* input */, v13.data() /* output */,
1791     threadpool /* threadpool */);
1792   if (status != xnn_status_success) {
1793     std::cerr << "failed to setup operation #12" << std::endl;
1794     return ExecutionPlan();
1795   }
1796 
1797   status = xnn_setup_convolution2d_nhwc_f16(
1798     op13,
1799     1 /* batch size */, 28 /* input height */, 28 /* input width */,
1800     v13.data() /* input */, v14.data() /* output */,
1801     threadpool /* threadpool */);
1802   if (status != xnn_status_success) {
1803     std::cerr << "failed to setup operation #13" << std::endl;
1804     return ExecutionPlan();
1805   }
1806 
1807   status = xnn_setup_convolution2d_nhwc_f16(
1808     op14,
1809     1 /* batch size */, 28 /* input height */, 28 /* input width */,
1810     v14.data() /* input */, v15.data() /* output */,
1811     threadpool /* threadpool */);
1812   if (status != xnn_status_success) {
1813     std::cerr << "failed to setup operation #14" << std::endl;
1814     return ExecutionPlan();
1815   }
1816 
1817   status = xnn_setup_convolution2d_nhwc_f16(
1818     op15,
1819     1 /* batch size */, 28 /* input height */, 28 /* input width */,
1820     v15.data() /* input */, v16.data() /* output */,
1821     threadpool /* threadpool */);
1822   if (status != xnn_status_success) {
1823     std::cerr << "failed to setup operation #15" << std::endl;
1824     return ExecutionPlan();
1825   }
1826 
1827   {
1828     const size_t a_shape[] = { 1, 28, 28, 32 };
1829     const size_t b_shape[] = { 1, 28, 28, 32 };
1830     status = xnn_setup_add_nd_f16(
1831       op16,
1832       4, a_shape, 4, b_shape,
1833       v16.data() /* a */, v13.data() /* b */, v17.data() /* output */,
1834       threadpool /* threadpool */);
1835   }
1836   if (status != xnn_status_success) {
1837     std::cerr << "failed to setup operation #16" << std::endl;
1838     return ExecutionPlan();
1839   }
1840 
1841   status = xnn_setup_convolution2d_nhwc_f16(
1842     op17,
1843     1 /* batch size */, 28 /* input height */, 28 /* input width */,
1844     v17.data() /* input */, v18.data() /* output */,
1845     threadpool /* threadpool */);
1846   if (status != xnn_status_success) {
1847     std::cerr << "failed to setup operation #17" << std::endl;
1848     return ExecutionPlan();
1849   }
1850 
1851   status = xnn_setup_convolution2d_nhwc_f16(
1852     op18,
1853     1 /* batch size */, 28 /* input height */, 28 /* input width */,
1854     v18.data() /* input */, v19.data() /* output */,
1855     threadpool /* threadpool */);
1856   if (status != xnn_status_success) {
1857     std::cerr << "failed to setup operation #18" << std::endl;
1858     return ExecutionPlan();
1859   }
1860 
1861   status = xnn_setup_convolution2d_nhwc_f16(
1862     op19,
1863     1 /* batch size */, 28 /* input height */, 28 /* input width */,
1864     v19.data() /* input */, v20.data() /* output */,
1865     threadpool /* threadpool */);
1866   if (status != xnn_status_success) {
1867     std::cerr << "failed to setup operation #19" << std::endl;
1868     return ExecutionPlan();
1869   }
1870 
1871   {
1872     const size_t a_shape[] = { 1, 28, 28, 32 };
1873     const size_t b_shape[] = { 1, 28, 28, 32 };
1874     status = xnn_setup_add_nd_f16(
1875       op20,
1876       4, a_shape, 4, b_shape,
1877       v20.data() /* a */, v17.data() /* b */, v21.data() /* output */,
1878       threadpool /* threadpool */);
1879   }
1880   if (status != xnn_status_success) {
1881     std::cerr << "failed to setup operation #20" << std::endl;
1882     return ExecutionPlan();
1883   }
1884 
1885   status = xnn_setup_convolution2d_nhwc_f16(
1886     op21,
1887     1 /* batch size */, 28 /* input height */, 28 /* input width */,
1888     v21.data() /* input */, v22.data() /* output */,
1889     threadpool /* threadpool */);
1890   if (status != xnn_status_success) {
1891     std::cerr << "failed to setup operation #21" << std::endl;
1892     return ExecutionPlan();
1893   }
1894 
1895   status = xnn_setup_convolution2d_nhwc_f16(
1896     op22,
1897     1 /* batch size */, 28 /* input height */, 28 /* input width */,
1898     v22.data() /* input */, v23.data() /* output */,
1899     threadpool /* threadpool */);
1900   if (status != xnn_status_success) {
1901     std::cerr << "failed to setup operation #22" << std::endl;
1902     return ExecutionPlan();
1903   }
1904 
1905   status = xnn_setup_convolution2d_nhwc_f16(
1906     op23,
1907     1 /* batch size */, 14 /* input height */, 14 /* input width */,
1908     v23.data() /* input */, v24.data() /* output */,
1909     threadpool /* threadpool */);
1910   if (status != xnn_status_success) {
1911     std::cerr << "failed to setup operation #23" << std::endl;
1912     return ExecutionPlan();
1913   }
1914 
1915   status = xnn_setup_convolution2d_nhwc_f16(
1916     op24,
1917     1 /* batch size */, 14 /* input height */, 14 /* input width */,
1918     v24.data() /* input */, v25.data() /* output */,
1919     threadpool /* threadpool */);
1920   if (status != xnn_status_success) {
1921     std::cerr << "failed to setup operation #24" << std::endl;
1922     return ExecutionPlan();
1923   }
1924 
1925   status = xnn_setup_convolution2d_nhwc_f16(
1926     op25,
1927     1 /* batch size */, 14 /* input height */, 14 /* input width */,
1928     v25.data() /* input */, v26.data() /* output */,
1929     threadpool /* threadpool */);
1930   if (status != xnn_status_success) {
1931     std::cerr << "failed to setup operation #25" << std::endl;
1932     return ExecutionPlan();
1933   }
1934 
1935   status = xnn_setup_convolution2d_nhwc_f16(
1936     op26,
1937     1 /* batch size */, 14 /* input height */, 14 /* input width */,
1938     v26.data() /* input */, v27.data() /* output */,
1939     threadpool /* threadpool */);
1940   if (status != xnn_status_success) {
1941     std::cerr << "failed to setup operation #26" << std::endl;
1942     return ExecutionPlan();
1943   }
1944 
1945   {
1946     const size_t a_shape[] = { 1, 14, 14, 64 };
1947     const size_t b_shape[] = { 1, 14, 14, 64 };
1948     status = xnn_setup_add_nd_f16(
1949       op27,
1950       4, a_shape, 4, b_shape,
1951       v27.data() /* a */, v24.data() /* b */, v28.data() /* output */,
1952       threadpool /* threadpool */);
1953   }
1954   if (status != xnn_status_success) {
1955     std::cerr << "failed to setup operation #27" << std::endl;
1956     return ExecutionPlan();
1957   }
1958 
1959   status = xnn_setup_convolution2d_nhwc_f16(
1960     op28,
1961     1 /* batch size */, 14 /* input height */, 14 /* input width */,
1962     v28.data() /* input */, v29.data() /* output */,
1963     threadpool /* threadpool */);
1964   if (status != xnn_status_success) {
1965     std::cerr << "failed to setup operation #28" << std::endl;
1966     return ExecutionPlan();
1967   }
1968 
1969   status = xnn_setup_convolution2d_nhwc_f16(
1970     op29,
1971     1 /* batch size */, 14 /* input height */, 14 /* input width */,
1972     v29.data() /* input */, v30.data() /* output */,
1973     threadpool /* threadpool */);
1974   if (status != xnn_status_success) {
1975     std::cerr << "failed to setup operation #29" << std::endl;
1976     return ExecutionPlan();
1977   }
1978 
1979   status = xnn_setup_convolution2d_nhwc_f16(
1980     op30,
1981     1 /* batch size */, 14 /* input height */, 14 /* input width */,
1982     v30.data() /* input */, v31.data() /* output */,
1983     threadpool /* threadpool */);
1984   if (status != xnn_status_success) {
1985     std::cerr << "failed to setup operation #30" << std::endl;
1986     return ExecutionPlan();
1987   }
1988 
1989   {
1990     const size_t a_shape[] = { 1, 14, 14, 64 };
1991     const size_t b_shape[] = { 1, 14, 14, 64 };
1992     status = xnn_setup_add_nd_f16(
1993       op31,
1994       4, a_shape, 4, b_shape,
1995       v31.data() /* a */, v28.data() /* b */, v32.data() /* output */,
1996       threadpool /* threadpool */);
1997   }
1998   if (status != xnn_status_success) {
1999     std::cerr << "failed to setup operation #31" << std::endl;
2000     return ExecutionPlan();
2001   }
2002 
2003   status = xnn_setup_convolution2d_nhwc_f16(
2004     op32,
2005     1 /* batch size */, 14 /* input height */, 14 /* input width */,
2006     v32.data() /* input */, v33.data() /* output */,
2007     threadpool /* threadpool */);
2008   if (status != xnn_status_success) {
2009     std::cerr << "failed to setup operation #32" << std::endl;
2010     return ExecutionPlan();
2011   }
2012 
2013   status = xnn_setup_convolution2d_nhwc_f16(
2014     op33,
2015     1 /* batch size */, 14 /* input height */, 14 /* input width */,
2016     v33.data() /* input */, v34.data() /* output */,
2017     threadpool /* threadpool */);
2018   if (status != xnn_status_success) {
2019     std::cerr << "failed to setup operation #33" << std::endl;
2020     return ExecutionPlan();
2021   }
2022 
2023   status = xnn_setup_convolution2d_nhwc_f16(
2024     op34,
2025     1 /* batch size */, 14 /* input height */, 14 /* input width */,
2026     v34.data() /* input */, v35.data() /* output */,
2027     threadpool /* threadpool */);
2028   if (status != xnn_status_success) {
2029     std::cerr << "failed to setup operation #34" << std::endl;
2030     return ExecutionPlan();
2031   }
2032 
2033   {
2034     const size_t a_shape[] = { 1, 14, 14, 64 };
2035     const size_t b_shape[] = { 1, 14, 14, 64 };
2036     status = xnn_setup_add_nd_f16(
2037       op35,
2038       4, a_shape, 4, b_shape,
2039       v35.data() /* a */, v32.data() /* b */, v36.data() /* output */,
2040       threadpool /* threadpool */);
2041   }
2042   if (status != xnn_status_success) {
2043     std::cerr << "failed to setup operation #35" << std::endl;
2044     return ExecutionPlan();
2045   }
2046 
2047   status = xnn_setup_convolution2d_nhwc_f16(
2048     op36,
2049     1 /* batch size */, 14 /* input height */, 14 /* input width */,
2050     v36.data() /* input */, v37.data() /* output */,
2051     threadpool /* threadpool */);
2052   if (status != xnn_status_success) {
2053     std::cerr << "failed to setup operation #36" << std::endl;
2054     return ExecutionPlan();
2055   }
2056 
2057   status = xnn_setup_convolution2d_nhwc_f16(
2058     op37,
2059     1 /* batch size */, 14 /* input height */, 14 /* input width */,
2060     v37.data() /* input */, v38.data() /* output */,
2061     threadpool /* threadpool */);
2062   if (status != xnn_status_success) {
2063     std::cerr << "failed to setup operation #37" << std::endl;
2064     return ExecutionPlan();
2065   }
2066 
2067   status = xnn_setup_convolution2d_nhwc_f16(
2068     op38,
2069     1 /* batch size */, 14 /* input height */, 14 /* input width */,
2070     v38.data() /* input */, v39.data() /* output */,
2071     threadpool /* threadpool */);
2072   if (status != xnn_status_success) {
2073     std::cerr << "failed to setup operation #38" << std::endl;
2074     return ExecutionPlan();
2075   }
2076 
2077   status = xnn_setup_convolution2d_nhwc_f16(
2078     op39,
2079     1 /* batch size */, 14 /* input height */, 14 /* input width */,
2080     v39.data() /* input */, v40.data() /* output */,
2081     threadpool /* threadpool */);
2082   if (status != xnn_status_success) {
2083     std::cerr << "failed to setup operation #39" << std::endl;
2084     return ExecutionPlan();
2085   }
2086 
2087   status = xnn_setup_convolution2d_nhwc_f16(
2088     op40,
2089     1 /* batch size */, 14 /* input height */, 14 /* input width */,
2090     v40.data() /* input */, v41.data() /* output */,
2091     threadpool /* threadpool */);
2092   if (status != xnn_status_success) {
2093     std::cerr << "failed to setup operation #40" << std::endl;
2094     return ExecutionPlan();
2095   }
2096 
2097   status = xnn_setup_convolution2d_nhwc_f16(
2098     op41,
2099     1 /* batch size */, 14 /* input height */, 14 /* input width */,
2100     v41.data() /* input */, v42.data() /* output */,
2101     threadpool /* threadpool */);
2102   if (status != xnn_status_success) {
2103     std::cerr << "failed to setup operation #41" << std::endl;
2104     return ExecutionPlan();
2105   }
2106 
2107   {
2108     const size_t a_shape[] = { 1, 14, 14, 96 };
2109     const size_t b_shape[] = { 1, 14, 14, 96 };
2110     status = xnn_setup_add_nd_f16(
2111       op42,
2112       4, a_shape, 4, b_shape,
2113       v42.data() /* a */, v39.data() /* b */, v43.data() /* output */,
2114       threadpool /* threadpool */);
2115   }
2116   if (status != xnn_status_success) {
2117     std::cerr << "failed to setup operation #42" << std::endl;
2118     return ExecutionPlan();
2119   }
2120 
2121   status = xnn_setup_convolution2d_nhwc_f16(
2122     op43,
2123     1 /* batch size */, 14 /* input height */, 14 /* input width */,
2124     v43.data() /* input */, v44.data() /* output */,
2125     threadpool /* threadpool */);
2126   if (status != xnn_status_success) {
2127     std::cerr << "failed to setup operation #43" << std::endl;
2128     return ExecutionPlan();
2129   }
2130 
2131   status = xnn_setup_convolution2d_nhwc_f16(
2132     op44,
2133     1 /* batch size */, 14 /* input height */, 14 /* input width */,
2134     v44.data() /* input */, v45.data() /* output */,
2135     threadpool /* threadpool */);
2136   if (status != xnn_status_success) {
2137     std::cerr << "failed to setup operation #44" << std::endl;
2138     return ExecutionPlan();
2139   }
2140 
2141   status = xnn_setup_convolution2d_nhwc_f16(
2142     op45,
2143     1 /* batch size */, 14 /* input height */, 14 /* input width */,
2144     v45.data() /* input */, v46.data() /* output */,
2145     threadpool /* threadpool */);
2146   if (status != xnn_status_success) {
2147     std::cerr << "failed to setup operation #45" << std::endl;
2148     return ExecutionPlan();
2149   }
2150 
2151   {
2152     const size_t a_shape[] = { 1, 14, 14, 96 };
2153     const size_t b_shape[] = { 1, 14, 14, 96 };
2154     status = xnn_setup_add_nd_f16(
2155       op46,
2156       4, a_shape, 4, b_shape,
2157       v46.data() /* a */, v43.data() /* b */, v47.data() /* output */,
2158       threadpool /* threadpool */);
2159   }
2160   if (status != xnn_status_success) {
2161     std::cerr << "failed to setup operation #46" << std::endl;
2162     return ExecutionPlan();
2163   }
2164 
2165   status = xnn_setup_convolution2d_nhwc_f16(
2166     op47,
2167     1 /* batch size */, 14 /* input height */, 14 /* input width */,
2168     v47.data() /* input */, v48.data() /* output */,
2169     threadpool /* threadpool */);
2170   if (status != xnn_status_success) {
2171     std::cerr << "failed to setup operation #47" << std::endl;
2172     return ExecutionPlan();
2173   }
2174 
2175   status = xnn_setup_convolution2d_nhwc_f16(
2176     op48,
2177     1 /* batch size */, 14 /* input height */, 14 /* input width */,
2178     v48.data() /* input */, v49.data() /* output */,
2179     threadpool /* threadpool */);
2180   if (status != xnn_status_success) {
2181     std::cerr << "failed to setup operation #48" << std::endl;
2182     return ExecutionPlan();
2183   }
2184 
2185   status = xnn_setup_convolution2d_nhwc_f16(
2186     op49,
2187     1 /* batch size */, 7 /* input height */, 7 /* input width */,
2188     v49.data() /* input */, v50.data() /* output */,
2189     threadpool /* threadpool */);
2190   if (status != xnn_status_success) {
2191     std::cerr << "failed to setup operation #49" << std::endl;
2192     return ExecutionPlan();
2193   }
2194 
2195   status = xnn_setup_convolution2d_nhwc_f16(
2196     op50,
2197     1 /* batch size */, 7 /* input height */, 7 /* input width */,
2198     v50.data() /* input */, v51.data() /* output */,
2199     threadpool /* threadpool */);
2200   if (status != xnn_status_success) {
2201     std::cerr << "failed to setup operation #50" << std::endl;
2202     return ExecutionPlan();
2203   }
2204 
2205   status = xnn_setup_convolution2d_nhwc_f16(
2206     op51,
2207     1 /* batch size */, 7 /* input height */, 7 /* input width */,
2208     v51.data() /* input */, v52.data() /* output */,
2209     threadpool /* threadpool */);
2210   if (status != xnn_status_success) {
2211     std::cerr << "failed to setup operation #51" << std::endl;
2212     return ExecutionPlan();
2213   }
2214 
2215   status = xnn_setup_convolution2d_nhwc_f16(
2216     op52,
2217     1 /* batch size */, 7 /* input height */, 7 /* input width */,
2218     v52.data() /* input */, v53.data() /* output */,
2219     threadpool /* threadpool */);
2220   if (status != xnn_status_success) {
2221     std::cerr << "failed to setup operation #52" << std::endl;
2222     return ExecutionPlan();
2223   }
2224 
2225   {
2226     const size_t a_shape[] = { 1, 7, 7, 160 };
2227     const size_t b_shape[] = { 1, 7, 7, 160 };
2228     status = xnn_setup_add_nd_f16(
2229       op53,
2230       4, a_shape, 4, b_shape,
2231       v53.data() /* a */, v50.data() /* b */, v54.data() /* output */,
2232       threadpool /* threadpool */);
2233   }
2234   if (status != xnn_status_success) {
2235     std::cerr << "failed to setup operation #53" << std::endl;
2236     return ExecutionPlan();
2237   }
2238 
2239   status = xnn_setup_convolution2d_nhwc_f16(
2240     op54,
2241     1 /* batch size */, 7 /* input height */, 7 /* input width */,
2242     v54.data() /* input */, v55.data() /* output */,
2243     threadpool /* threadpool */);
2244   if (status != xnn_status_success) {
2245     std::cerr << "failed to setup operation #54" << std::endl;
2246     return ExecutionPlan();
2247   }
2248 
2249   status = xnn_setup_convolution2d_nhwc_f16(
2250     op55,
2251     1 /* batch size */, 7 /* input height */, 7 /* input width */,
2252     v55.data() /* input */, v56.data() /* output */,
2253     threadpool /* threadpool */);
2254   if (status != xnn_status_success) {
2255     std::cerr << "failed to setup operation #55" << std::endl;
2256     return ExecutionPlan();
2257   }
2258 
2259   status = xnn_setup_convolution2d_nhwc_f16(
2260     op56,
2261     1 /* batch size */, 7 /* input height */, 7 /* input width */,
2262     v56.data() /* input */, v57.data() /* output */,
2263     threadpool /* threadpool */);
2264   if (status != xnn_status_success) {
2265     std::cerr << "failed to setup operation #56" << std::endl;
2266     return ExecutionPlan();
2267   }
2268 
2269   {
2270     const size_t a_shape[] = { 1, 7, 7, 160 };
2271     const size_t b_shape[] = { 1, 7, 7, 160 };
2272     status = xnn_setup_add_nd_f16(
2273       op57,
2274       4, a_shape, 4, b_shape,
2275       v57.data() /* a */, v54.data() /* b */, v58.data() /* output */,
2276       threadpool /* threadpool */);
2277   }
2278   if (status != xnn_status_success) {
2279     std::cerr << "failed to setup operation #57" << std::endl;
2280     return ExecutionPlan();
2281   }
2282 
2283   status = xnn_setup_convolution2d_nhwc_f16(
2284     op58,
2285     1 /* batch size */, 7 /* input height */, 7 /* input width */,
2286     v58.data() /* input */, v59.data() /* output */,
2287     threadpool /* threadpool */);
2288   if (status != xnn_status_success) {
2289     std::cerr << "failed to setup operation #58" << std::endl;
2290     return ExecutionPlan();
2291   }
2292 
2293   status = xnn_setup_convolution2d_nhwc_f16(
2294     op59,
2295     1 /* batch size */, 7 /* input height */, 7 /* input width */,
2296     v59.data() /* input */, v60.data() /* output */,
2297     threadpool /* threadpool */);
2298   if (status != xnn_status_success) {
2299     std::cerr << "failed to setup operation #59" << std::endl;
2300     return ExecutionPlan();
2301   }
2302 
2303   status = xnn_setup_convolution2d_nhwc_f16(
2304     op60,
2305     1 /* batch size */, 7 /* input height */, 7 /* input width */,
2306     v60.data() /* input */, v61.data() /* output */,
2307     threadpool /* threadpool */);
2308   if (status != xnn_status_success) {
2309     std::cerr << "failed to setup operation #60" << std::endl;
2310     return ExecutionPlan();
2311   }
2312 
2313   status = xnn_setup_convolution2d_nhwc_f16(
2314     op61,
2315     1 /* batch size */, 7 /* input height */, 7 /* input width */,
2316     v61.data() /* input */, v62.data() /* output */,
2317     threadpool /* threadpool */);
2318   if (status != xnn_status_success) {
2319     std::cerr << "failed to setup operation #61" << std::endl;
2320     return ExecutionPlan();
2321   }
2322 
2323   status = xnn_setup_global_average_pooling_nwc_f16(
2324     op62,
2325     1 /* batch size */, 49 /* width */,
2326     v62.data() /* input */, v63.data() /* output */,
2327     threadpool /* threadpool */);
2328   if (status != xnn_status_success) {
2329     std::cerr << "failed to setup operation #62" << std::endl;
2330     return ExecutionPlan();
2331   }
2332 
2333   status = xnn_setup_convolution2d_nhwc_f16(
2334     op63,
2335     1 /* batch size */, 1 /* input height */, 1 /* input width */,
2336     v63.data() /* input */, v64.data() /* output */,
2337     threadpool /* threadpool */);
2338   if (status != xnn_status_success) {
2339     std::cerr << "failed to setup operation #63" << std::endl;
2340     return ExecutionPlan();
2341   }
2342 
2343   #pragma clang diagnostic push
2344   #pragma clang diagnostic ignored "-Wpessimizing-move"
2345   return operators;
2346   #pragma clang diagnostic pop
2347 }
2348 
2349 }  // namespace models
2350