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