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