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