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