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