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