xref: /aosp_15_r20/external/XNNPACK/models/fp32-mobilenet-v1.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 
FP32MobileNetV1(pthreadpool_t threadpool)21 ExecutionPlan FP32MobileNetV1(pthreadpool_t threadpool) {
22   alignas(16) static std::array<float, 150528 + XNN_EXTRA_BYTES / sizeof(float)> v0;
23   alignas(16) static std::array<float, 401408> v1;
24   alignas(16) static std::array<float, 401408> v2;
25   alignas(16) static std::array<float, 802816> v3;
26   alignas(16) static std::array<float, 200704> v4;
27   alignas(16) static std::array<float, 401408> v5;
28   alignas(16) static std::array<float, 401408> v6;
29   alignas(16) static std::array<float, 401408> v7;
30   alignas(16) static std::array<float, 100352> v8;
31   alignas(16) static std::array<float, 200704> v9;
32   alignas(16) static std::array<float, 200704> v10;
33   alignas(16) static std::array<float, 200704> v11;
34   alignas(16) static std::array<float, 50176> v12;
35   alignas(16) static std::array<float, 100352> v13;
36   alignas(16) static std::array<float, 100352> v14;
37   alignas(16) static std::array<float, 100352> v15;
38   alignas(16) static std::array<float, 100352> v16;
39   alignas(16) static std::array<float, 100352> v17;
40   alignas(16) static std::array<float, 100352> v18;
41   alignas(16) static std::array<float, 100352> v19;
42   alignas(16) static std::array<float, 100352> v20;
43   alignas(16) static std::array<float, 100352> v21;
44   alignas(16) static std::array<float, 100352> v22;
45   alignas(16) static std::array<float, 100352> v23;
46   alignas(16) static std::array<float, 25088> v24;
47   alignas(16) static std::array<float, 50176> v25;
48   alignas(16) static std::array<float, 50176> v26;
49   alignas(16) static std::array<float, 50176> v27;
50   alignas(16) static std::array<float, 1024> v28;
51   alignas(16) static std::array<float, 1001> v29;
52   alignas(16) static std::array<float, 864> w30;
53   alignas(16) static std::array<float, 32> w31;
54   alignas(16) static std::array<float, 288> w32;
55   alignas(16) static std::array<float, 32> w33;
56   alignas(16) static std::array<float, 2048> w34;
57   alignas(16) static std::array<float, 64> w35;
58   alignas(16) static std::array<float, 576> w36;
59   alignas(16) static std::array<float, 64> w37;
60   alignas(16) static std::array<float, 8192> w38;
61   alignas(16) static std::array<float, 128> w39;
62   alignas(16) static std::array<float, 1152> w40;
63   alignas(16) static std::array<float, 128> w41;
64   alignas(16) static std::array<float, 16384> w42;
65   alignas(16) static std::array<float, 128> w43;
66   alignas(16) static std::array<float, 1152> w44;
67   alignas(16) static std::array<float, 128> w45;
68   alignas(16) static std::array<float, 32768> w46;
69   alignas(16) static std::array<float, 256> w47;
70   alignas(16) static std::array<float, 2304> w48;
71   alignas(16) static std::array<float, 256> w49;
72   alignas(16) static std::array<float, 65536> w50;
73   alignas(16) static std::array<float, 256> w51;
74   alignas(16) static std::array<float, 2304> w52;
75   alignas(16) static std::array<float, 256> w53;
76   alignas(16) static std::array<float, 131072> w54;
77   alignas(16) static std::array<float, 512> w55;
78   alignas(16) static std::array<float, 4608> w56;
79   alignas(16) static std::array<float, 512> w57;
80   alignas(16) static std::array<float, 262144> w58;
81   alignas(16) static std::array<float, 512> w59;
82   alignas(16) static std::array<float, 4608> w60;
83   alignas(16) static std::array<float, 512> w61;
84   alignas(16) static std::array<float, 262144> w62;
85   alignas(16) static std::array<float, 512> w63;
86   alignas(16) static std::array<float, 4608> w64;
87   alignas(16) static std::array<float, 512> w65;
88   alignas(16) static std::array<float, 262144> w66;
89   alignas(16) static std::array<float, 512> w67;
90   alignas(16) static std::array<float, 4608> w68;
91   alignas(16) static std::array<float, 512> w69;
92   alignas(16) static std::array<float, 262144> w70;
93   alignas(16) static std::array<float, 512> w71;
94   alignas(16) static std::array<float, 4608> w72;
95   alignas(16) static std::array<float, 512> w73;
96   alignas(16) static std::array<float, 262144> w74;
97   alignas(16) static std::array<float, 512> w75;
98   alignas(16) static std::array<float, 4608> w76;
99   alignas(16) static std::array<float, 512> w77;
100   alignas(16) static std::array<float, 524288> w78;
101   alignas(16) static std::array<float, 1024> w79;
102   alignas(16) static std::array<float, 9216> w80;
103   alignas(16) static std::array<float, 1024> w81;
104   alignas(16) static std::array<float, 1048576> w82;
105   alignas(16) static std::array<float, 1024> w83;
106   alignas(16) static std::array<float, 1025024> w84;
107   alignas(16) static std::array<float, 1001> w85;
108 
109   std::random_device random_device;
110   auto rng = std::mt19937(random_device());
111   auto f32rng = std::bind(std::uniform_real_distribution<float>(-1.0f, +1.0f), std::ref(rng));
112   std::generate(v0.begin(), v0.end(), std::ref(f32rng));
113   std::generate(v1.begin(), v1.end(), std::ref(f32rng));
114   std::generate(v2.begin(), v2.end(), std::ref(f32rng));
115   std::generate(v3.begin(), v3.end(), std::ref(f32rng));
116   std::generate(v4.begin(), v4.end(), std::ref(f32rng));
117   std::generate(v5.begin(), v5.end(), std::ref(f32rng));
118   std::generate(v6.begin(), v6.end(), std::ref(f32rng));
119   std::generate(v7.begin(), v7.end(), std::ref(f32rng));
120   std::generate(v8.begin(), v8.end(), std::ref(f32rng));
121   std::generate(v9.begin(), v9.end(), std::ref(f32rng));
122   std::generate(v10.begin(), v10.end(), std::ref(f32rng));
123   std::generate(v11.begin(), v11.end(), std::ref(f32rng));
124   std::generate(v12.begin(), v12.end(), std::ref(f32rng));
125   std::generate(v13.begin(), v13.end(), std::ref(f32rng));
126   std::generate(v14.begin(), v14.end(), std::ref(f32rng));
127   std::generate(v15.begin(), v15.end(), std::ref(f32rng));
128   std::generate(v16.begin(), v16.end(), std::ref(f32rng));
129   std::generate(v17.begin(), v17.end(), std::ref(f32rng));
130   std::generate(v18.begin(), v18.end(), std::ref(f32rng));
131   std::generate(v19.begin(), v19.end(), std::ref(f32rng));
132   std::generate(v20.begin(), v20.end(), std::ref(f32rng));
133   std::generate(v21.begin(), v21.end(), std::ref(f32rng));
134   std::generate(v22.begin(), v22.end(), std::ref(f32rng));
135   std::generate(v23.begin(), v23.end(), std::ref(f32rng));
136   std::generate(v24.begin(), v24.end(), std::ref(f32rng));
137   std::generate(v25.begin(), v25.end(), std::ref(f32rng));
138   std::generate(v26.begin(), v26.end(), std::ref(f32rng));
139   std::generate(v27.begin(), v27.end(), std::ref(f32rng));
140   std::generate(v28.begin(), v28.end(), std::ref(f32rng));
141   std::generate(v29.begin(), v29.end(), std::ref(f32rng));
142   std::generate(w30.begin(), w30.end(), std::ref(f32rng));
143   std::generate(w31.begin(), w31.end(), std::ref(f32rng));
144   std::generate(w32.begin(), w32.end(), std::ref(f32rng));
145   std::generate(w33.begin(), w33.end(), std::ref(f32rng));
146   std::generate(w34.begin(), w34.end(), std::ref(f32rng));
147   std::generate(w35.begin(), w35.end(), std::ref(f32rng));
148   std::generate(w36.begin(), w36.end(), std::ref(f32rng));
149   std::generate(w37.begin(), w37.end(), std::ref(f32rng));
150   std::generate(w38.begin(), w38.end(), std::ref(f32rng));
151   std::generate(w39.begin(), w39.end(), std::ref(f32rng));
152   std::generate(w40.begin(), w40.end(), std::ref(f32rng));
153   std::generate(w41.begin(), w41.end(), std::ref(f32rng));
154   std::generate(w42.begin(), w42.end(), std::ref(f32rng));
155   std::generate(w43.begin(), w43.end(), std::ref(f32rng));
156   std::generate(w44.begin(), w44.end(), std::ref(f32rng));
157   std::generate(w45.begin(), w45.end(), std::ref(f32rng));
158   std::generate(w46.begin(), w46.end(), std::ref(f32rng));
159   std::generate(w47.begin(), w47.end(), std::ref(f32rng));
160   std::generate(w48.begin(), w48.end(), std::ref(f32rng));
161   std::generate(w49.begin(), w49.end(), std::ref(f32rng));
162   std::generate(w50.begin(), w50.end(), std::ref(f32rng));
163   std::generate(w51.begin(), w51.end(), std::ref(f32rng));
164   std::generate(w52.begin(), w52.end(), std::ref(f32rng));
165   std::generate(w53.begin(), w53.end(), std::ref(f32rng));
166   std::generate(w54.begin(), w54.end(), std::ref(f32rng));
167   std::generate(w55.begin(), w55.end(), std::ref(f32rng));
168   std::generate(w56.begin(), w56.end(), std::ref(f32rng));
169   std::generate(w57.begin(), w57.end(), std::ref(f32rng));
170   std::generate(w58.begin(), w58.end(), std::ref(f32rng));
171   std::generate(w59.begin(), w59.end(), std::ref(f32rng));
172   std::generate(w60.begin(), w60.end(), std::ref(f32rng));
173   std::generate(w61.begin(), w61.end(), std::ref(f32rng));
174   std::generate(w62.begin(), w62.end(), std::ref(f32rng));
175   std::generate(w63.begin(), w63.end(), std::ref(f32rng));
176   std::generate(w64.begin(), w64.end(), std::ref(f32rng));
177   std::generate(w65.begin(), w65.end(), std::ref(f32rng));
178   std::generate(w66.begin(), w66.end(), std::ref(f32rng));
179   std::generate(w67.begin(), w67.end(), std::ref(f32rng));
180   std::generate(w68.begin(), w68.end(), std::ref(f32rng));
181   std::generate(w69.begin(), w69.end(), std::ref(f32rng));
182   std::generate(w70.begin(), w70.end(), std::ref(f32rng));
183   std::generate(w71.begin(), w71.end(), std::ref(f32rng));
184   std::generate(w72.begin(), w72.end(), std::ref(f32rng));
185   std::generate(w73.begin(), w73.end(), std::ref(f32rng));
186   std::generate(w74.begin(), w74.end(), std::ref(f32rng));
187   std::generate(w75.begin(), w75.end(), std::ref(f32rng));
188   std::generate(w76.begin(), w76.end(), std::ref(f32rng));
189   std::generate(w77.begin(), w77.end(), std::ref(f32rng));
190   std::generate(w78.begin(), w78.end(), std::ref(f32rng));
191   std::generate(w79.begin(), w79.end(), std::ref(f32rng));
192   std::generate(w80.begin(), w80.end(), std::ref(f32rng));
193   std::generate(w81.begin(), w81.end(), std::ref(f32rng));
194   std::generate(w82.begin(), w82.end(), std::ref(f32rng));
195   std::generate(w83.begin(), w83.end(), std::ref(f32rng));
196   std::generate(w84.begin(), w84.end(), std::ref(f32rng));
197   std::generate(w85.begin(), w85.end(), std::ref(f32rng));
198 
199   ExecutionPlan operators;
200   xnn_status status;
201   xnn_code_cache code_cache;
202 #if XNN_PLATFORM_JIT
203   xnn_init_code_cache(&code_cache);
204 #endif
205   xnn_caches caches = { 0 };
206   caches.code_cache = &code_cache;
207 
208   xnn_operator_t op0 = nullptr;
209   status = xnn_create_convolution2d_nhwc_f32(
210     0 /* top padding */, 1 /* right padding */,
211     1 /* bottom padding */, 0 /* left padding */,
212     3 /* kernel height */, 3 /* kernel width */,
213     2 /* subsampling height */, 2 /* subsampling width */,
214     1 /* dilation_height */, 1 /* dilation_width */,
215     1 /* groups */,
216     3 /* input channels per group */,
217     32 /* output_channels_per_group */,
218     3 /* input pixel stride */,
219     32 /* output pixel stride */,
220     w30.data(), w31.data(),
221     0.0f /* output min */, 6.0f /* output max */,
222     0 /* flags */,
223     &caches,
224     &op0);
225   if (status != xnn_status_success) {
226     std::cerr << "failed to create operation #0" << std::endl;
227     return ExecutionPlan();
228   }
229   operators.emplace_back(op0, xnn_delete_operator);
230 
231   xnn_operator_t op1 = nullptr;
232   status = xnn_create_convolution2d_nhwc_f32(
233     1 /* top padding */, 1 /* right padding */,
234     1 /* bottom padding */, 1 /* left padding */,
235     3 /* kernel height */, 3 /* kernel width */,
236     1 /* subsampling height */, 1 /* subsampling width */,
237     1 /* dilation_height */, 1 /* dilation_width */,
238     32 /* groups */,
239     1 /* input channels per group */,
240     1 /* output_channels_per_group */,
241     32 /* input pixel stride */,
242     32 /* output pixel stride */,
243     w32.data(), w33.data(),
244     0.0f /* output min */, 6.0f /* output max */,
245     0 /* flags */,
246     &caches,
247     &op1);
248   if (status != xnn_status_success) {
249     std::cerr << "failed to create operation #1" << std::endl;
250     return ExecutionPlan();
251   }
252   operators.emplace_back(op1, xnn_delete_operator);
253 
254   xnn_operator_t op2 = nullptr;
255   status = xnn_create_convolution2d_nhwc_f32(
256     0 /* top padding */, 0 /* right padding */,
257     0 /* bottom padding */, 0 /* left padding */,
258     1 /* kernel height */, 1 /* kernel width */,
259     1 /* subsampling height */, 1 /* subsampling width */,
260     1 /* dilation_height */, 1 /* dilation_width */,
261     1 /* groups */,
262     32 /* input channels per group */,
263     64 /* output_channels_per_group */,
264     32 /* input pixel stride */,
265     64 /* output pixel stride */,
266     w34.data(), w35.data(),
267     0.0f /* output min */, 6.0f /* output max */,
268     0 /* flags */,
269     &caches,
270     &op2);
271   if (status != xnn_status_success) {
272     std::cerr << "failed to create operation #2" << std::endl;
273     return ExecutionPlan();
274   }
275   operators.emplace_back(op2, xnn_delete_operator);
276 
277   xnn_operator_t op3 = nullptr;
278   status = xnn_create_convolution2d_nhwc_f32(
279     0 /* top padding */, 1 /* right padding */,
280     1 /* bottom padding */, 0 /* left padding */,
281     3 /* kernel height */, 3 /* kernel width */,
282     2 /* subsampling height */, 2 /* subsampling width */,
283     1 /* dilation_height */, 1 /* dilation_width */,
284     64 /* groups */,
285     1 /* input channels per group */,
286     1 /* output_channels_per_group */,
287     64 /* input pixel stride */,
288     64 /* output pixel stride */,
289     w36.data(), w37.data(),
290     0.0f /* output min */, 6.0f /* output max */,
291     0 /* flags */,
292     &caches,
293     &op3);
294   if (status != xnn_status_success) {
295     std::cerr << "failed to create operation #3" << std::endl;
296     return ExecutionPlan();
297   }
298   operators.emplace_back(op3, xnn_delete_operator);
299 
300   xnn_operator_t op4 = nullptr;
301   status = xnn_create_convolution2d_nhwc_f32(
302     0 /* top padding */, 0 /* right padding */,
303     0 /* bottom padding */, 0 /* left padding */,
304     1 /* kernel height */, 1 /* kernel width */,
305     1 /* subsampling height */, 1 /* subsampling width */,
306     1 /* dilation_height */, 1 /* dilation_width */,
307     1 /* groups */,
308     64 /* input channels per group */,
309     128 /* output_channels_per_group */,
310     64 /* input pixel stride */,
311     128 /* output pixel stride */,
312     w38.data(), w39.data(),
313     0.0f /* output min */, 6.0f /* output max */,
314     0 /* flags */,
315     &caches,
316     &op4);
317   if (status != xnn_status_success) {
318     std::cerr << "failed to create operation #4" << std::endl;
319     return ExecutionPlan();
320   }
321   operators.emplace_back(op4, xnn_delete_operator);
322 
323   xnn_operator_t op5 = nullptr;
324   status = xnn_create_convolution2d_nhwc_f32(
325     1 /* top padding */, 1 /* right padding */,
326     1 /* bottom padding */, 1 /* left padding */,
327     3 /* kernel height */, 3 /* kernel width */,
328     1 /* subsampling height */, 1 /* subsampling width */,
329     1 /* dilation_height */, 1 /* dilation_width */,
330     128 /* groups */,
331     1 /* input channels per group */,
332     1 /* output_channels_per_group */,
333     128 /* input pixel stride */,
334     128 /* output pixel stride */,
335     w40.data(), w41.data(),
336     0.0f /* output min */, 6.0f /* output max */,
337     0 /* flags */,
338     &caches,
339     &op5);
340   if (status != xnn_status_success) {
341     std::cerr << "failed to create operation #5" << std::endl;
342     return ExecutionPlan();
343   }
344   operators.emplace_back(op5, xnn_delete_operator);
345 
346   xnn_operator_t op6 = nullptr;
347   status = xnn_create_convolution2d_nhwc_f32(
348     0 /* top padding */, 0 /* right padding */,
349     0 /* bottom padding */, 0 /* left padding */,
350     1 /* kernel height */, 1 /* kernel width */,
351     1 /* subsampling height */, 1 /* subsampling width */,
352     1 /* dilation_height */, 1 /* dilation_width */,
353     1 /* groups */,
354     128 /* input channels per group */,
355     128 /* output_channels_per_group */,
356     128 /* input pixel stride */,
357     128 /* output pixel stride */,
358     w42.data(), w43.data(),
359     0.0f /* output min */, 6.0f /* output max */,
360     0 /* flags */,
361     &caches,
362     &op6);
363   if (status != xnn_status_success) {
364     std::cerr << "failed to create operation #6" << std::endl;
365     return ExecutionPlan();
366   }
367   operators.emplace_back(op6, xnn_delete_operator);
368 
369   xnn_operator_t op7 = nullptr;
370   status = xnn_create_convolution2d_nhwc_f32(
371     0 /* top padding */, 1 /* right padding */,
372     1 /* bottom padding */, 0 /* left padding */,
373     3 /* kernel height */, 3 /* kernel width */,
374     2 /* subsampling height */, 2 /* subsampling width */,
375     1 /* dilation_height */, 1 /* dilation_width */,
376     128 /* groups */,
377     1 /* input channels per group */,
378     1 /* output_channels_per_group */,
379     128 /* input pixel stride */,
380     128 /* output pixel stride */,
381     w44.data(), w45.data(),
382     0.0f /* output min */, 6.0f /* output max */,
383     0 /* flags */,
384     &caches,
385     &op7);
386   if (status != xnn_status_success) {
387     std::cerr << "failed to create operation #7" << std::endl;
388     return ExecutionPlan();
389   }
390   operators.emplace_back(op7, xnn_delete_operator);
391 
392   xnn_operator_t op8 = nullptr;
393   status = xnn_create_convolution2d_nhwc_f32(
394     0 /* top padding */, 0 /* right padding */,
395     0 /* bottom padding */, 0 /* left padding */,
396     1 /* kernel height */, 1 /* kernel width */,
397     1 /* subsampling height */, 1 /* subsampling width */,
398     1 /* dilation_height */, 1 /* dilation_width */,
399     1 /* groups */,
400     128 /* input channels per group */,
401     256 /* output_channels_per_group */,
402     128 /* input pixel stride */,
403     256 /* output pixel stride */,
404     w46.data(), w47.data(),
405     0.0f /* output min */, 6.0f /* output max */,
406     0 /* flags */,
407     &caches,
408     &op8);
409   if (status != xnn_status_success) {
410     std::cerr << "failed to create operation #8" << std::endl;
411     return ExecutionPlan();
412   }
413   operators.emplace_back(op8, xnn_delete_operator);
414 
415   xnn_operator_t op9 = nullptr;
416   status = xnn_create_convolution2d_nhwc_f32(
417     1 /* top padding */, 1 /* right padding */,
418     1 /* bottom padding */, 1 /* left padding */,
419     3 /* kernel height */, 3 /* kernel width */,
420     1 /* subsampling height */, 1 /* subsampling width */,
421     1 /* dilation_height */, 1 /* dilation_width */,
422     256 /* groups */,
423     1 /* input channels per group */,
424     1 /* output_channels_per_group */,
425     256 /* input pixel stride */,
426     256 /* output pixel stride */,
427     w48.data(), w49.data(),
428     0.0f /* output min */, 6.0f /* output max */,
429     0 /* flags */,
430     &caches,
431     &op9);
432   if (status != xnn_status_success) {
433     std::cerr << "failed to create operation #9" << std::endl;
434     return ExecutionPlan();
435   }
436   operators.emplace_back(op9, xnn_delete_operator);
437 
438   xnn_operator_t op10 = nullptr;
439   status = xnn_create_convolution2d_nhwc_f32(
440     0 /* top padding */, 0 /* right padding */,
441     0 /* bottom padding */, 0 /* left padding */,
442     1 /* kernel height */, 1 /* kernel width */,
443     1 /* subsampling height */, 1 /* subsampling width */,
444     1 /* dilation_height */, 1 /* dilation_width */,
445     1 /* groups */,
446     256 /* input channels per group */,
447     256 /* output_channels_per_group */,
448     256 /* input pixel stride */,
449     256 /* output pixel stride */,
450     w50.data(), w51.data(),
451     0.0f /* output min */, 6.0f /* output max */,
452     0 /* flags */,
453     &caches,
454     &op10);
455   if (status != xnn_status_success) {
456     std::cerr << "failed to create operation #10" << std::endl;
457     return ExecutionPlan();
458   }
459   operators.emplace_back(op10, xnn_delete_operator);
460 
461   xnn_operator_t op11 = nullptr;
462   status = xnn_create_convolution2d_nhwc_f32(
463     0 /* top padding */, 1 /* right padding */,
464     1 /* bottom padding */, 0 /* left padding */,
465     3 /* kernel height */, 3 /* kernel width */,
466     2 /* subsampling height */, 2 /* subsampling width */,
467     1 /* dilation_height */, 1 /* dilation_width */,
468     256 /* groups */,
469     1 /* input channels per group */,
470     1 /* output_channels_per_group */,
471     256 /* input pixel stride */,
472     256 /* output pixel stride */,
473     w52.data(), w53.data(),
474     0.0f /* output min */, 6.0f /* output max */,
475     0 /* flags */,
476     &caches,
477     &op11);
478   if (status != xnn_status_success) {
479     std::cerr << "failed to create operation #11" << std::endl;
480     return ExecutionPlan();
481   }
482   operators.emplace_back(op11, xnn_delete_operator);
483 
484   xnn_operator_t op12 = nullptr;
485   status = xnn_create_convolution2d_nhwc_f32(
486     0 /* top padding */, 0 /* right padding */,
487     0 /* bottom padding */, 0 /* left padding */,
488     1 /* kernel height */, 1 /* kernel width */,
489     1 /* subsampling height */, 1 /* subsampling width */,
490     1 /* dilation_height */, 1 /* dilation_width */,
491     1 /* groups */,
492     256 /* input channels per group */,
493     512 /* output_channels_per_group */,
494     256 /* input pixel stride */,
495     512 /* output pixel stride */,
496     w54.data(), w55.data(),
497     0.0f /* output min */, 6.0f /* output max */,
498     0 /* flags */,
499     &caches,
500     &op12);
501   if (status != xnn_status_success) {
502     std::cerr << "failed to create operation #12" << std::endl;
503     return ExecutionPlan();
504   }
505   operators.emplace_back(op12, xnn_delete_operator);
506 
507   xnn_operator_t op13 = nullptr;
508   status = xnn_create_convolution2d_nhwc_f32(
509     1 /* top padding */, 1 /* right padding */,
510     1 /* bottom padding */, 1 /* left padding */,
511     3 /* kernel height */, 3 /* kernel width */,
512     1 /* subsampling height */, 1 /* subsampling width */,
513     1 /* dilation_height */, 1 /* dilation_width */,
514     512 /* groups */,
515     1 /* input channels per group */,
516     1 /* output_channels_per_group */,
517     512 /* input pixel stride */,
518     512 /* output pixel stride */,
519     w56.data(), w57.data(),
520     0.0f /* output min */, 6.0f /* output max */,
521     0 /* flags */,
522     &caches,
523     &op13);
524   if (status != xnn_status_success) {
525     std::cerr << "failed to create operation #13" << std::endl;
526     return ExecutionPlan();
527   }
528   operators.emplace_back(op13, xnn_delete_operator);
529 
530   xnn_operator_t op14 = nullptr;
531   status = xnn_create_convolution2d_nhwc_f32(
532     0 /* top padding */, 0 /* right padding */,
533     0 /* bottom padding */, 0 /* left padding */,
534     1 /* kernel height */, 1 /* kernel width */,
535     1 /* subsampling height */, 1 /* subsampling width */,
536     1 /* dilation_height */, 1 /* dilation_width */,
537     1 /* groups */,
538     512 /* input channels per group */,
539     512 /* output_channels_per_group */,
540     512 /* input pixel stride */,
541     512 /* output pixel stride */,
542     w58.data(), w59.data(),
543     0.0f /* output min */, 6.0f /* output max */,
544     0 /* flags */,
545     &caches,
546     &op14);
547   if (status != xnn_status_success) {
548     std::cerr << "failed to create operation #14" << std::endl;
549     return ExecutionPlan();
550   }
551   operators.emplace_back(op14, xnn_delete_operator);
552 
553   xnn_operator_t op15 = nullptr;
554   status = xnn_create_convolution2d_nhwc_f32(
555     1 /* top padding */, 1 /* right padding */,
556     1 /* bottom padding */, 1 /* left padding */,
557     3 /* kernel height */, 3 /* kernel width */,
558     1 /* subsampling height */, 1 /* subsampling width */,
559     1 /* dilation_height */, 1 /* dilation_width */,
560     512 /* groups */,
561     1 /* input channels per group */,
562     1 /* output_channels_per_group */,
563     512 /* input pixel stride */,
564     512 /* output pixel stride */,
565     w60.data(), w61.data(),
566     0.0f /* output min */, 6.0f /* output max */,
567     0 /* flags */,
568     &caches,
569     &op15);
570   if (status != xnn_status_success) {
571     std::cerr << "failed to create operation #15" << std::endl;
572     return ExecutionPlan();
573   }
574   operators.emplace_back(op15, xnn_delete_operator);
575 
576   xnn_operator_t op16 = nullptr;
577   status = xnn_create_convolution2d_nhwc_f32(
578     0 /* top padding */, 0 /* right padding */,
579     0 /* bottom padding */, 0 /* left padding */,
580     1 /* kernel height */, 1 /* kernel width */,
581     1 /* subsampling height */, 1 /* subsampling width */,
582     1 /* dilation_height */, 1 /* dilation_width */,
583     1 /* groups */,
584     512 /* input channels per group */,
585     512 /* output_channels_per_group */,
586     512 /* input pixel stride */,
587     512 /* output pixel stride */,
588     w62.data(), w63.data(),
589     0.0f /* output min */, 6.0f /* output max */,
590     0 /* flags */,
591     &caches,
592     &op16);
593   if (status != xnn_status_success) {
594     std::cerr << "failed to create operation #16" << std::endl;
595     return ExecutionPlan();
596   }
597   operators.emplace_back(op16, xnn_delete_operator);
598 
599   xnn_operator_t op17 = nullptr;
600   status = xnn_create_convolution2d_nhwc_f32(
601     1 /* top padding */, 1 /* right padding */,
602     1 /* bottom padding */, 1 /* left padding */,
603     3 /* kernel height */, 3 /* kernel width */,
604     1 /* subsampling height */, 1 /* subsampling width */,
605     1 /* dilation_height */, 1 /* dilation_width */,
606     512 /* groups */,
607     1 /* input channels per group */,
608     1 /* output_channels_per_group */,
609     512 /* input pixel stride */,
610     512 /* output pixel stride */,
611     w64.data(), w65.data(),
612     0.0f /* output min */, 6.0f /* output max */,
613     0 /* flags */,
614     &caches,
615     &op17);
616   if (status != xnn_status_success) {
617     std::cerr << "failed to create operation #17" << std::endl;
618     return ExecutionPlan();
619   }
620   operators.emplace_back(op17, xnn_delete_operator);
621 
622   xnn_operator_t op18 = nullptr;
623   status = xnn_create_convolution2d_nhwc_f32(
624     0 /* top padding */, 0 /* right padding */,
625     0 /* bottom padding */, 0 /* left padding */,
626     1 /* kernel height */, 1 /* kernel width */,
627     1 /* subsampling height */, 1 /* subsampling width */,
628     1 /* dilation_height */, 1 /* dilation_width */,
629     1 /* groups */,
630     512 /* input channels per group */,
631     512 /* output_channels_per_group */,
632     512 /* input pixel stride */,
633     512 /* output pixel stride */,
634     w66.data(), w67.data(),
635     0.0f /* output min */, 6.0f /* output max */,
636     0 /* flags */,
637     &caches,
638     &op18);
639   if (status != xnn_status_success) {
640     std::cerr << "failed to create operation #18" << std::endl;
641     return ExecutionPlan();
642   }
643   operators.emplace_back(op18, xnn_delete_operator);
644 
645   xnn_operator_t op19 = nullptr;
646   status = xnn_create_convolution2d_nhwc_f32(
647     1 /* top padding */, 1 /* right padding */,
648     1 /* bottom padding */, 1 /* left padding */,
649     3 /* kernel height */, 3 /* kernel width */,
650     1 /* subsampling height */, 1 /* subsampling width */,
651     1 /* dilation_height */, 1 /* dilation_width */,
652     512 /* groups */,
653     1 /* input channels per group */,
654     1 /* output_channels_per_group */,
655     512 /* input pixel stride */,
656     512 /* output pixel stride */,
657     w68.data(), w69.data(),
658     0.0f /* output min */, 6.0f /* output max */,
659     0 /* flags */,
660     &caches,
661     &op19);
662   if (status != xnn_status_success) {
663     std::cerr << "failed to create operation #19" << std::endl;
664     return ExecutionPlan();
665   }
666   operators.emplace_back(op19, xnn_delete_operator);
667 
668   xnn_operator_t op20 = nullptr;
669   status = xnn_create_convolution2d_nhwc_f32(
670     0 /* top padding */, 0 /* right padding */,
671     0 /* bottom padding */, 0 /* left padding */,
672     1 /* kernel height */, 1 /* kernel width */,
673     1 /* subsampling height */, 1 /* subsampling width */,
674     1 /* dilation_height */, 1 /* dilation_width */,
675     1 /* groups */,
676     512 /* input channels per group */,
677     512 /* output_channels_per_group */,
678     512 /* input pixel stride */,
679     512 /* output pixel stride */,
680     w70.data(), w71.data(),
681     0.0f /* output min */, 6.0f /* output max */,
682     0 /* flags */,
683     &caches,
684     &op20);
685   if (status != xnn_status_success) {
686     std::cerr << "failed to create operation #20" << std::endl;
687     return ExecutionPlan();
688   }
689   operators.emplace_back(op20, xnn_delete_operator);
690 
691   xnn_operator_t op21 = nullptr;
692   status = xnn_create_convolution2d_nhwc_f32(
693     1 /* top padding */, 1 /* right padding */,
694     1 /* bottom padding */, 1 /* left padding */,
695     3 /* kernel height */, 3 /* kernel width */,
696     1 /* subsampling height */, 1 /* subsampling width */,
697     1 /* dilation_height */, 1 /* dilation_width */,
698     512 /* groups */,
699     1 /* input channels per group */,
700     1 /* output_channels_per_group */,
701     512 /* input pixel stride */,
702     512 /* output pixel stride */,
703     w72.data(), w73.data(),
704     0.0f /* output min */, 6.0f /* output max */,
705     0 /* flags */,
706     &caches,
707     &op21);
708   if (status != xnn_status_success) {
709     std::cerr << "failed to create operation #21" << std::endl;
710     return ExecutionPlan();
711   }
712   operators.emplace_back(op21, xnn_delete_operator);
713 
714   xnn_operator_t op22 = nullptr;
715   status = xnn_create_convolution2d_nhwc_f32(
716     0 /* top padding */, 0 /* right padding */,
717     0 /* bottom padding */, 0 /* left padding */,
718     1 /* kernel height */, 1 /* kernel width */,
719     1 /* subsampling height */, 1 /* subsampling width */,
720     1 /* dilation_height */, 1 /* dilation_width */,
721     1 /* groups */,
722     512 /* input channels per group */,
723     512 /* output_channels_per_group */,
724     512 /* input pixel stride */,
725     512 /* output pixel stride */,
726     w74.data(), w75.data(),
727     0.0f /* output min */, 6.0f /* output max */,
728     0 /* flags */,
729     &caches,
730     &op22);
731   if (status != xnn_status_success) {
732     std::cerr << "failed to create operation #22" << std::endl;
733     return ExecutionPlan();
734   }
735   operators.emplace_back(op22, xnn_delete_operator);
736 
737   xnn_operator_t op23 = nullptr;
738   status = xnn_create_convolution2d_nhwc_f32(
739     0 /* top padding */, 1 /* right padding */,
740     1 /* bottom padding */, 0 /* left padding */,
741     3 /* kernel height */, 3 /* kernel width */,
742     2 /* subsampling height */, 2 /* subsampling width */,
743     1 /* dilation_height */, 1 /* dilation_width */,
744     512 /* groups */,
745     1 /* input channels per group */,
746     1 /* output_channels_per_group */,
747     512 /* input pixel stride */,
748     512 /* output pixel stride */,
749     w76.data(), w77.data(),
750     0.0f /* output min */, 6.0f /* output max */,
751     0 /* flags */,
752     &caches,
753     &op23);
754   if (status != xnn_status_success) {
755     std::cerr << "failed to create operation #23" << std::endl;
756     return ExecutionPlan();
757   }
758   operators.emplace_back(op23, xnn_delete_operator);
759 
760   xnn_operator_t op24 = nullptr;
761   status = xnn_create_convolution2d_nhwc_f32(
762     0 /* top padding */, 0 /* right padding */,
763     0 /* bottom padding */, 0 /* left padding */,
764     1 /* kernel height */, 1 /* kernel width */,
765     1 /* subsampling height */, 1 /* subsampling width */,
766     1 /* dilation_height */, 1 /* dilation_width */,
767     1 /* groups */,
768     512 /* input channels per group */,
769     1024 /* output_channels_per_group */,
770     512 /* input pixel stride */,
771     1024 /* output pixel stride */,
772     w78.data(), w79.data(),
773     0.0f /* output min */, 6.0f /* output max */,
774     0 /* flags */,
775     &caches,
776     &op24);
777   if (status != xnn_status_success) {
778     std::cerr << "failed to create operation #24" << std::endl;
779     return ExecutionPlan();
780   }
781   operators.emplace_back(op24, xnn_delete_operator);
782 
783   xnn_operator_t op25 = nullptr;
784   status = xnn_create_convolution2d_nhwc_f32(
785     1 /* top padding */, 1 /* right padding */,
786     1 /* bottom padding */, 1 /* left padding */,
787     3 /* kernel height */, 3 /* kernel width */,
788     1 /* subsampling height */, 1 /* subsampling width */,
789     1 /* dilation_height */, 1 /* dilation_width */,
790     1024 /* groups */,
791     1 /* input channels per group */,
792     1 /* output_channels_per_group */,
793     1024 /* input pixel stride */,
794     1024 /* output pixel stride */,
795     w80.data(), w81.data(),
796     0.0f /* output min */, 6.0f /* output max */,
797     0 /* flags */,
798     &caches,
799     &op25);
800   if (status != xnn_status_success) {
801     std::cerr << "failed to create operation #25" << std::endl;
802     return ExecutionPlan();
803   }
804   operators.emplace_back(op25, xnn_delete_operator);
805 
806   xnn_operator_t op26 = nullptr;
807   status = xnn_create_convolution2d_nhwc_f32(
808     0 /* top padding */, 0 /* right padding */,
809     0 /* bottom padding */, 0 /* left padding */,
810     1 /* kernel height */, 1 /* kernel width */,
811     1 /* subsampling height */, 1 /* subsampling width */,
812     1 /* dilation_height */, 1 /* dilation_width */,
813     1 /* groups */,
814     1024 /* input channels per group */,
815     1024 /* output_channels_per_group */,
816     1024 /* input pixel stride */,
817     1024 /* output pixel stride */,
818     w82.data(), w83.data(),
819     0.0f /* output min */, 6.0f /* output max */,
820     0 /* flags */,
821     &caches,
822     &op26);
823   if (status != xnn_status_success) {
824     std::cerr << "failed to create operation #26" << std::endl;
825     return ExecutionPlan();
826   }
827   operators.emplace_back(op26, xnn_delete_operator);
828 
829   xnn_operator_t op27 = nullptr;
830   status = xnn_create_global_average_pooling_nwc_f32(
831     1024 /* channels */, 1024 /* input stride */, 1024 /* output stride */,
832     -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
833     0 /* flags */,
834     &op27);
835   if (status != xnn_status_success) {
836     std::cerr << "failed to create operation #27" << std::endl;
837     return ExecutionPlan();
838   }
839   operators.emplace_back(op27, xnn_delete_operator);
840 
841   xnn_operator_t op28 = nullptr;
842   status = xnn_create_convolution2d_nhwc_f32(
843     0 /* top padding */, 0 /* right padding */,
844     0 /* bottom padding */, 0 /* left padding */,
845     1 /* kernel height */, 1 /* kernel width */,
846     1 /* subsampling height */, 1 /* subsampling width */,
847     1 /* dilation_height */, 1 /* dilation_width */,
848     1 /* groups */,
849     1024 /* input channels per group */,
850     1001 /* output_channels_per_group */,
851     1024 /* input pixel stride */,
852     1001 /* output pixel stride */,
853     w84.data(), w85.data(),
854     -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
855     0 /* flags */,
856     &caches,
857     &op28);
858   if (status != xnn_status_success) {
859     std::cerr << "failed to create operation #28" << std::endl;
860     return ExecutionPlan();
861   }
862   operators.emplace_back(op28, xnn_delete_operator);
863 
864 #if XNN_PLATFORM_JIT
865   xnn_finalize_code_memory(&code_cache.cache.code);
866 #endif
867 
868   status = xnn_setup_convolution2d_nhwc_f32(
869     op0,
870     1 /* batch size */, 224 /* input height */, 224 /* input width */,
871     v0.data() /* input */, v1.data() /* output */,
872     threadpool /* threadpool */);
873   if (status != xnn_status_success) {
874     std::cerr << "failed to setup operation #0" << std::endl;
875     return ExecutionPlan();
876   }
877 
878   status = xnn_setup_convolution2d_nhwc_f32(
879     op1,
880     1 /* batch size */, 112 /* input height */, 112 /* input width */,
881     v1.data() /* input */, v2.data() /* output */,
882     threadpool /* threadpool */);
883   if (status != xnn_status_success) {
884     std::cerr << "failed to setup operation #1" << std::endl;
885     return ExecutionPlan();
886   }
887 
888   status = xnn_setup_convolution2d_nhwc_f32(
889     op2,
890     1 /* batch size */, 112 /* input height */, 112 /* input width */,
891     v2.data() /* input */, v3.data() /* output */,
892     threadpool /* threadpool */);
893   if (status != xnn_status_success) {
894     std::cerr << "failed to setup operation #2" << std::endl;
895     return ExecutionPlan();
896   }
897 
898   status = xnn_setup_convolution2d_nhwc_f32(
899     op3,
900     1 /* batch size */, 112 /* input height */, 112 /* input width */,
901     v3.data() /* input */, v4.data() /* output */,
902     threadpool /* threadpool */);
903   if (status != xnn_status_success) {
904     std::cerr << "failed to setup operation #3" << std::endl;
905     return ExecutionPlan();
906   }
907 
908   status = xnn_setup_convolution2d_nhwc_f32(
909     op4,
910     1 /* batch size */, 56 /* input height */, 56 /* input width */,
911     v4.data() /* input */, v5.data() /* output */,
912     threadpool /* threadpool */);
913   if (status != xnn_status_success) {
914     std::cerr << "failed to setup operation #4" << std::endl;
915     return ExecutionPlan();
916   }
917 
918   status = xnn_setup_convolution2d_nhwc_f32(
919     op5,
920     1 /* batch size */, 56 /* input height */, 56 /* input width */,
921     v5.data() /* input */, v6.data() /* output */,
922     threadpool /* threadpool */);
923   if (status != xnn_status_success) {
924     std::cerr << "failed to setup operation #5" << std::endl;
925     return ExecutionPlan();
926   }
927 
928   status = xnn_setup_convolution2d_nhwc_f32(
929     op6,
930     1 /* batch size */, 56 /* input height */, 56 /* input width */,
931     v6.data() /* input */, v7.data() /* output */,
932     threadpool /* threadpool */);
933   if (status != xnn_status_success) {
934     std::cerr << "failed to setup operation #6" << std::endl;
935     return ExecutionPlan();
936   }
937 
938   status = xnn_setup_convolution2d_nhwc_f32(
939     op7,
940     1 /* batch size */, 56 /* input height */, 56 /* input width */,
941     v7.data() /* input */, v8.data() /* output */,
942     threadpool /* threadpool */);
943   if (status != xnn_status_success) {
944     std::cerr << "failed to setup operation #7" << std::endl;
945     return ExecutionPlan();
946   }
947 
948   status = xnn_setup_convolution2d_nhwc_f32(
949     op8,
950     1 /* batch size */, 28 /* input height */, 28 /* input width */,
951     v8.data() /* input */, v9.data() /* output */,
952     threadpool /* threadpool */);
953   if (status != xnn_status_success) {
954     std::cerr << "failed to setup operation #8" << std::endl;
955     return ExecutionPlan();
956   }
957 
958   status = xnn_setup_convolution2d_nhwc_f32(
959     op9,
960     1 /* batch size */, 28 /* input height */, 28 /* input width */,
961     v9.data() /* input */, v10.data() /* output */,
962     threadpool /* threadpool */);
963   if (status != xnn_status_success) {
964     std::cerr << "failed to setup operation #9" << std::endl;
965     return ExecutionPlan();
966   }
967 
968   status = xnn_setup_convolution2d_nhwc_f32(
969     op10,
970     1 /* batch size */, 28 /* input height */, 28 /* input width */,
971     v10.data() /* input */, v11.data() /* output */,
972     threadpool /* threadpool */);
973   if (status != xnn_status_success) {
974     std::cerr << "failed to setup operation #10" << std::endl;
975     return ExecutionPlan();
976   }
977 
978   status = xnn_setup_convolution2d_nhwc_f32(
979     op11,
980     1 /* batch size */, 28 /* input height */, 28 /* input width */,
981     v11.data() /* input */, v12.data() /* output */,
982     threadpool /* threadpool */);
983   if (status != xnn_status_success) {
984     std::cerr << "failed to setup operation #11" << std::endl;
985     return ExecutionPlan();
986   }
987 
988   status = xnn_setup_convolution2d_nhwc_f32(
989     op12,
990     1 /* batch size */, 14 /* input height */, 14 /* input width */,
991     v12.data() /* input */, v13.data() /* output */,
992     threadpool /* threadpool */);
993   if (status != xnn_status_success) {
994     std::cerr << "failed to setup operation #12" << std::endl;
995     return ExecutionPlan();
996   }
997 
998   status = xnn_setup_convolution2d_nhwc_f32(
999     op13,
1000     1 /* batch size */, 14 /* input height */, 14 /* input width */,
1001     v13.data() /* input */, v14.data() /* output */,
1002     threadpool /* threadpool */);
1003   if (status != xnn_status_success) {
1004     std::cerr << "failed to setup operation #13" << std::endl;
1005     return ExecutionPlan();
1006   }
1007 
1008   status = xnn_setup_convolution2d_nhwc_f32(
1009     op14,
1010     1 /* batch size */, 14 /* input height */, 14 /* input width */,
1011     v14.data() /* input */, v15.data() /* output */,
1012     threadpool /* threadpool */);
1013   if (status != xnn_status_success) {
1014     std::cerr << "failed to setup operation #14" << std::endl;
1015     return ExecutionPlan();
1016   }
1017 
1018   status = xnn_setup_convolution2d_nhwc_f32(
1019     op15,
1020     1 /* batch size */, 14 /* input height */, 14 /* input width */,
1021     v15.data() /* input */, v16.data() /* output */,
1022     threadpool /* threadpool */);
1023   if (status != xnn_status_success) {
1024     std::cerr << "failed to setup operation #15" << std::endl;
1025     return ExecutionPlan();
1026   }
1027 
1028   status = xnn_setup_convolution2d_nhwc_f32(
1029     op16,
1030     1 /* batch size */, 14 /* input height */, 14 /* input width */,
1031     v16.data() /* input */, v17.data() /* output */,
1032     threadpool /* threadpool */);
1033   if (status != xnn_status_success) {
1034     std::cerr << "failed to setup operation #16" << std::endl;
1035     return ExecutionPlan();
1036   }
1037 
1038   status = xnn_setup_convolution2d_nhwc_f32(
1039     op17,
1040     1 /* batch size */, 14 /* input height */, 14 /* input width */,
1041     v17.data() /* input */, v18.data() /* output */,
1042     threadpool /* threadpool */);
1043   if (status != xnn_status_success) {
1044     std::cerr << "failed to setup operation #17" << std::endl;
1045     return ExecutionPlan();
1046   }
1047 
1048   status = xnn_setup_convolution2d_nhwc_f32(
1049     op18,
1050     1 /* batch size */, 14 /* input height */, 14 /* input width */,
1051     v18.data() /* input */, v19.data() /* output */,
1052     threadpool /* threadpool */);
1053   if (status != xnn_status_success) {
1054     std::cerr << "failed to setup operation #18" << std::endl;
1055     return ExecutionPlan();
1056   }
1057 
1058   status = xnn_setup_convolution2d_nhwc_f32(
1059     op19,
1060     1 /* batch size */, 14 /* input height */, 14 /* input width */,
1061     v19.data() /* input */, v20.data() /* output */,
1062     threadpool /* threadpool */);
1063   if (status != xnn_status_success) {
1064     std::cerr << "failed to setup operation #19" << std::endl;
1065     return ExecutionPlan();
1066   }
1067 
1068   status = xnn_setup_convolution2d_nhwc_f32(
1069     op20,
1070     1 /* batch size */, 14 /* input height */, 14 /* input width */,
1071     v20.data() /* input */, v21.data() /* output */,
1072     threadpool /* threadpool */);
1073   if (status != xnn_status_success) {
1074     std::cerr << "failed to setup operation #20" << std::endl;
1075     return ExecutionPlan();
1076   }
1077 
1078   status = xnn_setup_convolution2d_nhwc_f32(
1079     op21,
1080     1 /* batch size */, 14 /* input height */, 14 /* input width */,
1081     v21.data() /* input */, v22.data() /* output */,
1082     threadpool /* threadpool */);
1083   if (status != xnn_status_success) {
1084     std::cerr << "failed to setup operation #21" << std::endl;
1085     return ExecutionPlan();
1086   }
1087 
1088   status = xnn_setup_convolution2d_nhwc_f32(
1089     op22,
1090     1 /* batch size */, 14 /* input height */, 14 /* input width */,
1091     v22.data() /* input */, v23.data() /* output */,
1092     threadpool /* threadpool */);
1093   if (status != xnn_status_success) {
1094     std::cerr << "failed to setup operation #22" << std::endl;
1095     return ExecutionPlan();
1096   }
1097 
1098   status = xnn_setup_convolution2d_nhwc_f32(
1099     op23,
1100     1 /* batch size */, 14 /* input height */, 14 /* input width */,
1101     v23.data() /* input */, v24.data() /* output */,
1102     threadpool /* threadpool */);
1103   if (status != xnn_status_success) {
1104     std::cerr << "failed to setup operation #23" << std::endl;
1105     return ExecutionPlan();
1106   }
1107 
1108   status = xnn_setup_convolution2d_nhwc_f32(
1109     op24,
1110     1 /* batch size */, 7 /* input height */, 7 /* input width */,
1111     v24.data() /* input */, v25.data() /* output */,
1112     threadpool /* threadpool */);
1113   if (status != xnn_status_success) {
1114     std::cerr << "failed to setup operation #24" << std::endl;
1115     return ExecutionPlan();
1116   }
1117 
1118   status = xnn_setup_convolution2d_nhwc_f32(
1119     op25,
1120     1 /* batch size */, 7 /* input height */, 7 /* input width */,
1121     v25.data() /* input */, v26.data() /* output */,
1122     threadpool /* threadpool */);
1123   if (status != xnn_status_success) {
1124     std::cerr << "failed to setup operation #25" << std::endl;
1125     return ExecutionPlan();
1126   }
1127 
1128   status = xnn_setup_convolution2d_nhwc_f32(
1129     op26,
1130     1 /* batch size */, 7 /* input height */, 7 /* input width */,
1131     v26.data() /* input */, v27.data() /* output */,
1132     threadpool /* threadpool */);
1133   if (status != xnn_status_success) {
1134     std::cerr << "failed to setup operation #26" << std::endl;
1135     return ExecutionPlan();
1136   }
1137 
1138   status = xnn_setup_global_average_pooling_nwc_f32(
1139     op27,
1140     1 /* batch size */, 49 /* width */,
1141     v27.data() /* input */, v28.data() /* output */,
1142     threadpool /* threadpool */);
1143   if (status != xnn_status_success) {
1144     std::cerr << "failed to setup operation #27" << std::endl;
1145     return ExecutionPlan();
1146   }
1147 
1148   status = xnn_setup_convolution2d_nhwc_f32(
1149     op28,
1150     1 /* batch size */, 1 /* input height */, 1 /* input width */,
1151     v28.data() /* input */, v29.data() /* output */,
1152     threadpool /* threadpool */);
1153   if (status != xnn_status_success) {
1154     std::cerr << "failed to setup operation #28" << std::endl;
1155     return ExecutionPlan();
1156   }
1157 
1158   #pragma clang diagnostic push
1159   #pragma clang diagnostic ignored "-Wpessimizing-move"
1160   return operators;
1161   #pragma clang diagnostic pop
1162 }
1163 
1164 }  // namespace models
1165