1 /*
2 * Copyright (C) by Argonne National Laboratory
3 * See COPYRIGHT in top-level directory
4 *
5 * DO NOT EDIT: AUTOMATICALLY GENERATED FILE !!
6 */
7
8 #include <string.h>
9 #include <stdint.h>
10 #include <wchar.h>
11 #include "yaksuri_seqi_pup.h"
12
yaksuri_seqi_pack_hvector_hvector_blklen_1_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)13 int yaksuri_seqi_pack_hvector_hvector_blklen_1_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
14 {
15 int rc = YAKSA_SUCCESS;
16 const char *restrict sbuf = (const char *) inbuf;
17 char *restrict dbuf = (char *) outbuf;
18 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
19
20 int count1 = type->u.hvector.count;
21 int blocklength1 ATTRIBUTE((unused)) = type->u.hvector.blocklength;
22 intptr_t stride1 = type->u.hvector.stride;
23 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
24
25 int count2 = type->u.hvector.child->u.hvector.count;
26 int blocklength2 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.blocklength;
27 intptr_t stride2 = type->u.hvector.child->u.hvector.stride;
28 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.hvector.child->extent;
29
30 uintptr_t idx = 0;
31 for (int i = 0; i < count; i++) {
32 for (int j1 = 0; j1 < count1; j1++) {
33 for (int k1 = 0; k1 < blocklength1; k1++) {
34 for (int j2 = 0; j2 < count2; j2++) {
35 for (int k2 = 0; k2 < 1; k2++) {
36 *((int8_t *) (void *) (dbuf + idx)) = *((const int8_t *) (const void *) (sbuf + i * extent + j1 * stride1 + k1 * extent2 + j2 * stride2 + k2 * sizeof(int8_t)));
37 idx += sizeof(int8_t);
38 }
39 }
40 }
41 }
42 }
43
44 return rc;
45 }
46
yaksuri_seqi_unpack_hvector_hvector_blklen_1_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)47 int yaksuri_seqi_unpack_hvector_hvector_blklen_1_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
48 {
49 int rc = YAKSA_SUCCESS;
50 const char *restrict sbuf = (const char *) inbuf;
51 char *restrict dbuf = (char *) outbuf;
52 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
53
54 int count1 = type->u.hvector.count;
55 int blocklength1 ATTRIBUTE((unused)) = type->u.hvector.blocklength;
56 intptr_t stride1 = type->u.hvector.stride;
57 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
58
59 int count2 = type->u.hvector.child->u.hvector.count;
60 int blocklength2 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.blocklength;
61 intptr_t stride2 = type->u.hvector.child->u.hvector.stride;
62 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.hvector.child->extent;
63
64 uintptr_t idx = 0;
65 for (int i = 0; i < count; i++) {
66 for (int j1 = 0; j1 < count1; j1++) {
67 for (int k1 = 0; k1 < blocklength1; k1++) {
68 for (int j2 = 0; j2 < count2; j2++) {
69 for (int k2 = 0; k2 < 1; k2++) {
70 *((int8_t *) (void *) (dbuf + i * extent + j1 * stride1 + k1 * extent2 + j2 * stride2 + k2 * sizeof(int8_t))) = *((const int8_t *) (const void *) (sbuf + idx));
71 idx += sizeof(int8_t);
72 }
73 }
74 }
75 }
76 }
77
78 return rc;
79 }
80
yaksuri_seqi_pack_hvector_hvector_blklen_2_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)81 int yaksuri_seqi_pack_hvector_hvector_blklen_2_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
82 {
83 int rc = YAKSA_SUCCESS;
84 const char *restrict sbuf = (const char *) inbuf;
85 char *restrict dbuf = (char *) outbuf;
86 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
87
88 int count1 = type->u.hvector.count;
89 int blocklength1 ATTRIBUTE((unused)) = type->u.hvector.blocklength;
90 intptr_t stride1 = type->u.hvector.stride;
91 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
92
93 int count2 = type->u.hvector.child->u.hvector.count;
94 int blocklength2 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.blocklength;
95 intptr_t stride2 = type->u.hvector.child->u.hvector.stride;
96 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.hvector.child->extent;
97
98 uintptr_t idx = 0;
99 for (int i = 0; i < count; i++) {
100 for (int j1 = 0; j1 < count1; j1++) {
101 for (int k1 = 0; k1 < blocklength1; k1++) {
102 for (int j2 = 0; j2 < count2; j2++) {
103 for (int k2 = 0; k2 < 2; k2++) {
104 *((int8_t *) (void *) (dbuf + idx)) = *((const int8_t *) (const void *) (sbuf + i * extent + j1 * stride1 + k1 * extent2 + j2 * stride2 + k2 * sizeof(int8_t)));
105 idx += sizeof(int8_t);
106 }
107 }
108 }
109 }
110 }
111
112 return rc;
113 }
114
yaksuri_seqi_unpack_hvector_hvector_blklen_2_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)115 int yaksuri_seqi_unpack_hvector_hvector_blklen_2_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
116 {
117 int rc = YAKSA_SUCCESS;
118 const char *restrict sbuf = (const char *) inbuf;
119 char *restrict dbuf = (char *) outbuf;
120 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
121
122 int count1 = type->u.hvector.count;
123 int blocklength1 ATTRIBUTE((unused)) = type->u.hvector.blocklength;
124 intptr_t stride1 = type->u.hvector.stride;
125 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
126
127 int count2 = type->u.hvector.child->u.hvector.count;
128 int blocklength2 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.blocklength;
129 intptr_t stride2 = type->u.hvector.child->u.hvector.stride;
130 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.hvector.child->extent;
131
132 uintptr_t idx = 0;
133 for (int i = 0; i < count; i++) {
134 for (int j1 = 0; j1 < count1; j1++) {
135 for (int k1 = 0; k1 < blocklength1; k1++) {
136 for (int j2 = 0; j2 < count2; j2++) {
137 for (int k2 = 0; k2 < 2; k2++) {
138 *((int8_t *) (void *) (dbuf + i * extent + j1 * stride1 + k1 * extent2 + j2 * stride2 + k2 * sizeof(int8_t))) = *((const int8_t *) (const void *) (sbuf + idx));
139 idx += sizeof(int8_t);
140 }
141 }
142 }
143 }
144 }
145
146 return rc;
147 }
148
yaksuri_seqi_pack_hvector_hvector_blklen_3_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)149 int yaksuri_seqi_pack_hvector_hvector_blklen_3_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
150 {
151 int rc = YAKSA_SUCCESS;
152 const char *restrict sbuf = (const char *) inbuf;
153 char *restrict dbuf = (char *) outbuf;
154 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
155
156 int count1 = type->u.hvector.count;
157 int blocklength1 ATTRIBUTE((unused)) = type->u.hvector.blocklength;
158 intptr_t stride1 = type->u.hvector.stride;
159 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
160
161 int count2 = type->u.hvector.child->u.hvector.count;
162 int blocklength2 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.blocklength;
163 intptr_t stride2 = type->u.hvector.child->u.hvector.stride;
164 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.hvector.child->extent;
165
166 uintptr_t idx = 0;
167 for (int i = 0; i < count; i++) {
168 for (int j1 = 0; j1 < count1; j1++) {
169 for (int k1 = 0; k1 < blocklength1; k1++) {
170 for (int j2 = 0; j2 < count2; j2++) {
171 for (int k2 = 0; k2 < 3; k2++) {
172 *((int8_t *) (void *) (dbuf + idx)) = *((const int8_t *) (const void *) (sbuf + i * extent + j1 * stride1 + k1 * extent2 + j2 * stride2 + k2 * sizeof(int8_t)));
173 idx += sizeof(int8_t);
174 }
175 }
176 }
177 }
178 }
179
180 return rc;
181 }
182
yaksuri_seqi_unpack_hvector_hvector_blklen_3_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)183 int yaksuri_seqi_unpack_hvector_hvector_blklen_3_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
184 {
185 int rc = YAKSA_SUCCESS;
186 const char *restrict sbuf = (const char *) inbuf;
187 char *restrict dbuf = (char *) outbuf;
188 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
189
190 int count1 = type->u.hvector.count;
191 int blocklength1 ATTRIBUTE((unused)) = type->u.hvector.blocklength;
192 intptr_t stride1 = type->u.hvector.stride;
193 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
194
195 int count2 = type->u.hvector.child->u.hvector.count;
196 int blocklength2 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.blocklength;
197 intptr_t stride2 = type->u.hvector.child->u.hvector.stride;
198 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.hvector.child->extent;
199
200 uintptr_t idx = 0;
201 for (int i = 0; i < count; i++) {
202 for (int j1 = 0; j1 < count1; j1++) {
203 for (int k1 = 0; k1 < blocklength1; k1++) {
204 for (int j2 = 0; j2 < count2; j2++) {
205 for (int k2 = 0; k2 < 3; k2++) {
206 *((int8_t *) (void *) (dbuf + i * extent + j1 * stride1 + k1 * extent2 + j2 * stride2 + k2 * sizeof(int8_t))) = *((const int8_t *) (const void *) (sbuf + idx));
207 idx += sizeof(int8_t);
208 }
209 }
210 }
211 }
212 }
213
214 return rc;
215 }
216
yaksuri_seqi_pack_hvector_hvector_blklen_4_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)217 int yaksuri_seqi_pack_hvector_hvector_blklen_4_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
218 {
219 int rc = YAKSA_SUCCESS;
220 const char *restrict sbuf = (const char *) inbuf;
221 char *restrict dbuf = (char *) outbuf;
222 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
223
224 int count1 = type->u.hvector.count;
225 int blocklength1 ATTRIBUTE((unused)) = type->u.hvector.blocklength;
226 intptr_t stride1 = type->u.hvector.stride;
227 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
228
229 int count2 = type->u.hvector.child->u.hvector.count;
230 int blocklength2 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.blocklength;
231 intptr_t stride2 = type->u.hvector.child->u.hvector.stride;
232 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.hvector.child->extent;
233
234 uintptr_t idx = 0;
235 for (int i = 0; i < count; i++) {
236 for (int j1 = 0; j1 < count1; j1++) {
237 for (int k1 = 0; k1 < blocklength1; k1++) {
238 for (int j2 = 0; j2 < count2; j2++) {
239 for (int k2 = 0; k2 < 4; k2++) {
240 *((int8_t *) (void *) (dbuf + idx)) = *((const int8_t *) (const void *) (sbuf + i * extent + j1 * stride1 + k1 * extent2 + j2 * stride2 + k2 * sizeof(int8_t)));
241 idx += sizeof(int8_t);
242 }
243 }
244 }
245 }
246 }
247
248 return rc;
249 }
250
yaksuri_seqi_unpack_hvector_hvector_blklen_4_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)251 int yaksuri_seqi_unpack_hvector_hvector_blklen_4_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
252 {
253 int rc = YAKSA_SUCCESS;
254 const char *restrict sbuf = (const char *) inbuf;
255 char *restrict dbuf = (char *) outbuf;
256 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
257
258 int count1 = type->u.hvector.count;
259 int blocklength1 ATTRIBUTE((unused)) = type->u.hvector.blocklength;
260 intptr_t stride1 = type->u.hvector.stride;
261 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
262
263 int count2 = type->u.hvector.child->u.hvector.count;
264 int blocklength2 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.blocklength;
265 intptr_t stride2 = type->u.hvector.child->u.hvector.stride;
266 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.hvector.child->extent;
267
268 uintptr_t idx = 0;
269 for (int i = 0; i < count; i++) {
270 for (int j1 = 0; j1 < count1; j1++) {
271 for (int k1 = 0; k1 < blocklength1; k1++) {
272 for (int j2 = 0; j2 < count2; j2++) {
273 for (int k2 = 0; k2 < 4; k2++) {
274 *((int8_t *) (void *) (dbuf + i * extent + j1 * stride1 + k1 * extent2 + j2 * stride2 + k2 * sizeof(int8_t))) = *((const int8_t *) (const void *) (sbuf + idx));
275 idx += sizeof(int8_t);
276 }
277 }
278 }
279 }
280 }
281
282 return rc;
283 }
284
yaksuri_seqi_pack_hvector_hvector_blklen_5_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)285 int yaksuri_seqi_pack_hvector_hvector_blklen_5_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
286 {
287 int rc = YAKSA_SUCCESS;
288 const char *restrict sbuf = (const char *) inbuf;
289 char *restrict dbuf = (char *) outbuf;
290 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
291
292 int count1 = type->u.hvector.count;
293 int blocklength1 ATTRIBUTE((unused)) = type->u.hvector.blocklength;
294 intptr_t stride1 = type->u.hvector.stride;
295 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
296
297 int count2 = type->u.hvector.child->u.hvector.count;
298 int blocklength2 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.blocklength;
299 intptr_t stride2 = type->u.hvector.child->u.hvector.stride;
300 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.hvector.child->extent;
301
302 uintptr_t idx = 0;
303 for (int i = 0; i < count; i++) {
304 for (int j1 = 0; j1 < count1; j1++) {
305 for (int k1 = 0; k1 < blocklength1; k1++) {
306 for (int j2 = 0; j2 < count2; j2++) {
307 for (int k2 = 0; k2 < 5; k2++) {
308 *((int8_t *) (void *) (dbuf + idx)) = *((const int8_t *) (const void *) (sbuf + i * extent + j1 * stride1 + k1 * extent2 + j2 * stride2 + k2 * sizeof(int8_t)));
309 idx += sizeof(int8_t);
310 }
311 }
312 }
313 }
314 }
315
316 return rc;
317 }
318
yaksuri_seqi_unpack_hvector_hvector_blklen_5_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)319 int yaksuri_seqi_unpack_hvector_hvector_blklen_5_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
320 {
321 int rc = YAKSA_SUCCESS;
322 const char *restrict sbuf = (const char *) inbuf;
323 char *restrict dbuf = (char *) outbuf;
324 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
325
326 int count1 = type->u.hvector.count;
327 int blocklength1 ATTRIBUTE((unused)) = type->u.hvector.blocklength;
328 intptr_t stride1 = type->u.hvector.stride;
329 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
330
331 int count2 = type->u.hvector.child->u.hvector.count;
332 int blocklength2 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.blocklength;
333 intptr_t stride2 = type->u.hvector.child->u.hvector.stride;
334 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.hvector.child->extent;
335
336 uintptr_t idx = 0;
337 for (int i = 0; i < count; i++) {
338 for (int j1 = 0; j1 < count1; j1++) {
339 for (int k1 = 0; k1 < blocklength1; k1++) {
340 for (int j2 = 0; j2 < count2; j2++) {
341 for (int k2 = 0; k2 < 5; k2++) {
342 *((int8_t *) (void *) (dbuf + i * extent + j1 * stride1 + k1 * extent2 + j2 * stride2 + k2 * sizeof(int8_t))) = *((const int8_t *) (const void *) (sbuf + idx));
343 idx += sizeof(int8_t);
344 }
345 }
346 }
347 }
348 }
349
350 return rc;
351 }
352
yaksuri_seqi_pack_hvector_hvector_blklen_6_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)353 int yaksuri_seqi_pack_hvector_hvector_blklen_6_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
354 {
355 int rc = YAKSA_SUCCESS;
356 const char *restrict sbuf = (const char *) inbuf;
357 char *restrict dbuf = (char *) outbuf;
358 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
359
360 int count1 = type->u.hvector.count;
361 int blocklength1 ATTRIBUTE((unused)) = type->u.hvector.blocklength;
362 intptr_t stride1 = type->u.hvector.stride;
363 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
364
365 int count2 = type->u.hvector.child->u.hvector.count;
366 int blocklength2 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.blocklength;
367 intptr_t stride2 = type->u.hvector.child->u.hvector.stride;
368 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.hvector.child->extent;
369
370 uintptr_t idx = 0;
371 for (int i = 0; i < count; i++) {
372 for (int j1 = 0; j1 < count1; j1++) {
373 for (int k1 = 0; k1 < blocklength1; k1++) {
374 for (int j2 = 0; j2 < count2; j2++) {
375 for (int k2 = 0; k2 < 6; k2++) {
376 *((int8_t *) (void *) (dbuf + idx)) = *((const int8_t *) (const void *) (sbuf + i * extent + j1 * stride1 + k1 * extent2 + j2 * stride2 + k2 * sizeof(int8_t)));
377 idx += sizeof(int8_t);
378 }
379 }
380 }
381 }
382 }
383
384 return rc;
385 }
386
yaksuri_seqi_unpack_hvector_hvector_blklen_6_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)387 int yaksuri_seqi_unpack_hvector_hvector_blklen_6_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
388 {
389 int rc = YAKSA_SUCCESS;
390 const char *restrict sbuf = (const char *) inbuf;
391 char *restrict dbuf = (char *) outbuf;
392 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
393
394 int count1 = type->u.hvector.count;
395 int blocklength1 ATTRIBUTE((unused)) = type->u.hvector.blocklength;
396 intptr_t stride1 = type->u.hvector.stride;
397 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
398
399 int count2 = type->u.hvector.child->u.hvector.count;
400 int blocklength2 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.blocklength;
401 intptr_t stride2 = type->u.hvector.child->u.hvector.stride;
402 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.hvector.child->extent;
403
404 uintptr_t idx = 0;
405 for (int i = 0; i < count; i++) {
406 for (int j1 = 0; j1 < count1; j1++) {
407 for (int k1 = 0; k1 < blocklength1; k1++) {
408 for (int j2 = 0; j2 < count2; j2++) {
409 for (int k2 = 0; k2 < 6; k2++) {
410 *((int8_t *) (void *) (dbuf + i * extent + j1 * stride1 + k1 * extent2 + j2 * stride2 + k2 * sizeof(int8_t))) = *((const int8_t *) (const void *) (sbuf + idx));
411 idx += sizeof(int8_t);
412 }
413 }
414 }
415 }
416 }
417
418 return rc;
419 }
420
yaksuri_seqi_pack_hvector_hvector_blklen_7_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)421 int yaksuri_seqi_pack_hvector_hvector_blklen_7_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
422 {
423 int rc = YAKSA_SUCCESS;
424 const char *restrict sbuf = (const char *) inbuf;
425 char *restrict dbuf = (char *) outbuf;
426 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
427
428 int count1 = type->u.hvector.count;
429 int blocklength1 ATTRIBUTE((unused)) = type->u.hvector.blocklength;
430 intptr_t stride1 = type->u.hvector.stride;
431 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
432
433 int count2 = type->u.hvector.child->u.hvector.count;
434 int blocklength2 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.blocklength;
435 intptr_t stride2 = type->u.hvector.child->u.hvector.stride;
436 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.hvector.child->extent;
437
438 uintptr_t idx = 0;
439 for (int i = 0; i < count; i++) {
440 for (int j1 = 0; j1 < count1; j1++) {
441 for (int k1 = 0; k1 < blocklength1; k1++) {
442 for (int j2 = 0; j2 < count2; j2++) {
443 for (int k2 = 0; k2 < 7; k2++) {
444 *((int8_t *) (void *) (dbuf + idx)) = *((const int8_t *) (const void *) (sbuf + i * extent + j1 * stride1 + k1 * extent2 + j2 * stride2 + k2 * sizeof(int8_t)));
445 idx += sizeof(int8_t);
446 }
447 }
448 }
449 }
450 }
451
452 return rc;
453 }
454
yaksuri_seqi_unpack_hvector_hvector_blklen_7_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)455 int yaksuri_seqi_unpack_hvector_hvector_blklen_7_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
456 {
457 int rc = YAKSA_SUCCESS;
458 const char *restrict sbuf = (const char *) inbuf;
459 char *restrict dbuf = (char *) outbuf;
460 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
461
462 int count1 = type->u.hvector.count;
463 int blocklength1 ATTRIBUTE((unused)) = type->u.hvector.blocklength;
464 intptr_t stride1 = type->u.hvector.stride;
465 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
466
467 int count2 = type->u.hvector.child->u.hvector.count;
468 int blocklength2 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.blocklength;
469 intptr_t stride2 = type->u.hvector.child->u.hvector.stride;
470 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.hvector.child->extent;
471
472 uintptr_t idx = 0;
473 for (int i = 0; i < count; i++) {
474 for (int j1 = 0; j1 < count1; j1++) {
475 for (int k1 = 0; k1 < blocklength1; k1++) {
476 for (int j2 = 0; j2 < count2; j2++) {
477 for (int k2 = 0; k2 < 7; k2++) {
478 *((int8_t *) (void *) (dbuf + i * extent + j1 * stride1 + k1 * extent2 + j2 * stride2 + k2 * sizeof(int8_t))) = *((const int8_t *) (const void *) (sbuf + idx));
479 idx += sizeof(int8_t);
480 }
481 }
482 }
483 }
484 }
485
486 return rc;
487 }
488
yaksuri_seqi_pack_hvector_hvector_blklen_8_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)489 int yaksuri_seqi_pack_hvector_hvector_blklen_8_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
490 {
491 int rc = YAKSA_SUCCESS;
492 const char *restrict sbuf = (const char *) inbuf;
493 char *restrict dbuf = (char *) outbuf;
494 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
495
496 int count1 = type->u.hvector.count;
497 int blocklength1 ATTRIBUTE((unused)) = type->u.hvector.blocklength;
498 intptr_t stride1 = type->u.hvector.stride;
499 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
500
501 int count2 = type->u.hvector.child->u.hvector.count;
502 int blocklength2 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.blocklength;
503 intptr_t stride2 = type->u.hvector.child->u.hvector.stride;
504 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.hvector.child->extent;
505
506 uintptr_t idx = 0;
507 for (int i = 0; i < count; i++) {
508 for (int j1 = 0; j1 < count1; j1++) {
509 for (int k1 = 0; k1 < blocklength1; k1++) {
510 for (int j2 = 0; j2 < count2; j2++) {
511 for (int k2 = 0; k2 < 8; k2++) {
512 *((int8_t *) (void *) (dbuf + idx)) = *((const int8_t *) (const void *) (sbuf + i * extent + j1 * stride1 + k1 * extent2 + j2 * stride2 + k2 * sizeof(int8_t)));
513 idx += sizeof(int8_t);
514 }
515 }
516 }
517 }
518 }
519
520 return rc;
521 }
522
yaksuri_seqi_unpack_hvector_hvector_blklen_8_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)523 int yaksuri_seqi_unpack_hvector_hvector_blklen_8_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
524 {
525 int rc = YAKSA_SUCCESS;
526 const char *restrict sbuf = (const char *) inbuf;
527 char *restrict dbuf = (char *) outbuf;
528 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
529
530 int count1 = type->u.hvector.count;
531 int blocklength1 ATTRIBUTE((unused)) = type->u.hvector.blocklength;
532 intptr_t stride1 = type->u.hvector.stride;
533 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
534
535 int count2 = type->u.hvector.child->u.hvector.count;
536 int blocklength2 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.blocklength;
537 intptr_t stride2 = type->u.hvector.child->u.hvector.stride;
538 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.hvector.child->extent;
539
540 uintptr_t idx = 0;
541 for (int i = 0; i < count; i++) {
542 for (int j1 = 0; j1 < count1; j1++) {
543 for (int k1 = 0; k1 < blocklength1; k1++) {
544 for (int j2 = 0; j2 < count2; j2++) {
545 for (int k2 = 0; k2 < 8; k2++) {
546 *((int8_t *) (void *) (dbuf + i * extent + j1 * stride1 + k1 * extent2 + j2 * stride2 + k2 * sizeof(int8_t))) = *((const int8_t *) (const void *) (sbuf + idx));
547 idx += sizeof(int8_t);
548 }
549 }
550 }
551 }
552 }
553
554 return rc;
555 }
556
yaksuri_seqi_pack_hvector_hvector_blklen_generic_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)557 int yaksuri_seqi_pack_hvector_hvector_blklen_generic_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
558 {
559 int rc = YAKSA_SUCCESS;
560 const char *restrict sbuf = (const char *) inbuf;
561 char *restrict dbuf = (char *) outbuf;
562 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
563
564 int count1 = type->u.hvector.count;
565 int blocklength1 ATTRIBUTE((unused)) = type->u.hvector.blocklength;
566 intptr_t stride1 = type->u.hvector.stride;
567 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
568
569 int count2 = type->u.hvector.child->u.hvector.count;
570 int blocklength2 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.blocklength;
571 intptr_t stride2 = type->u.hvector.child->u.hvector.stride;
572 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.hvector.child->extent;
573
574 uintptr_t idx = 0;
575 for (int i = 0; i < count; i++) {
576 for (int j1 = 0; j1 < count1; j1++) {
577 for (int k1 = 0; k1 < blocklength1; k1++) {
578 for (int j2 = 0; j2 < count2; j2++) {
579 for (int k2 = 0; k2 < blocklength2; k2++) {
580 *((int8_t *) (void *) (dbuf + idx)) = *((const int8_t *) (const void *) (sbuf + i * extent + j1 * stride1 + k1 * extent2 + j2 * stride2 + k2 * sizeof(int8_t)));
581 idx += sizeof(int8_t);
582 }
583 }
584 }
585 }
586 }
587
588 return rc;
589 }
590
yaksuri_seqi_unpack_hvector_hvector_blklen_generic_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)591 int yaksuri_seqi_unpack_hvector_hvector_blklen_generic_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
592 {
593 int rc = YAKSA_SUCCESS;
594 const char *restrict sbuf = (const char *) inbuf;
595 char *restrict dbuf = (char *) outbuf;
596 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
597
598 int count1 = type->u.hvector.count;
599 int blocklength1 ATTRIBUTE((unused)) = type->u.hvector.blocklength;
600 intptr_t stride1 = type->u.hvector.stride;
601 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
602
603 int count2 = type->u.hvector.child->u.hvector.count;
604 int blocklength2 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.blocklength;
605 intptr_t stride2 = type->u.hvector.child->u.hvector.stride;
606 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.hvector.child->extent;
607
608 uintptr_t idx = 0;
609 for (int i = 0; i < count; i++) {
610 for (int j1 = 0; j1 < count1; j1++) {
611 for (int k1 = 0; k1 < blocklength1; k1++) {
612 for (int j2 = 0; j2 < count2; j2++) {
613 for (int k2 = 0; k2 < blocklength2; k2++) {
614 *((int8_t *) (void *) (dbuf + i * extent + j1 * stride1 + k1 * extent2 + j2 * stride2 + k2 * sizeof(int8_t))) = *((const int8_t *) (const void *) (sbuf + idx));
615 idx += sizeof(int8_t);
616 }
617 }
618 }
619 }
620 }
621
622 return rc;
623 }
624
yaksuri_seqi_pack_hvector_hvector_hvector_blklen_1_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)625 int yaksuri_seqi_pack_hvector_hvector_hvector_blklen_1_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
626 {
627 int rc = YAKSA_SUCCESS;
628 const char *restrict sbuf = (const char *) inbuf;
629 char *restrict dbuf = (char *) outbuf;
630 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
631
632 int count1 = type->u.hvector.count;
633 int blocklength1 ATTRIBUTE((unused)) = type->u.hvector.blocklength;
634 intptr_t stride1 = type->u.hvector.stride;
635 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
636
637 int count2 = type->u.hvector.child->u.hvector.count;
638 int blocklength2 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.blocklength;
639 intptr_t stride2 = type->u.hvector.child->u.hvector.stride;
640 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.hvector.child->extent;
641
642 int count3 = type->u.hvector.child->u.hvector.child->u.hvector.count;
643 int blocklength3 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.child->u.hvector.blocklength;
644 intptr_t stride3 = type->u.hvector.child->u.hvector.child->u.hvector.stride;
645 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.child->extent;
646
647 uintptr_t idx = 0;
648 for (int i = 0; i < count; i++) {
649 for (int j1 = 0; j1 < count1; j1++) {
650 for (int k1 = 0; k1 < blocklength1; k1++) {
651 for (int j2 = 0; j2 < count2; j2++) {
652 for (int k2 = 0; k2 < blocklength2; k2++) {
653 for (int j3 = 0; j3 < count3; j3++) {
654 for (int k3 = 0; k3 < 1; k3++) {
655 *((int8_t *) (void *) (dbuf + idx)) = *((const int8_t *) (const void *) (sbuf + i * extent + j1 * stride1 + k1 * extent2 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t)));
656 idx += sizeof(int8_t);
657 }
658 }
659 }
660 }
661 }
662 }
663 }
664
665 return rc;
666 }
667
yaksuri_seqi_unpack_hvector_hvector_hvector_blklen_1_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)668 int yaksuri_seqi_unpack_hvector_hvector_hvector_blklen_1_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
669 {
670 int rc = YAKSA_SUCCESS;
671 const char *restrict sbuf = (const char *) inbuf;
672 char *restrict dbuf = (char *) outbuf;
673 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
674
675 int count1 = type->u.hvector.count;
676 int blocklength1 ATTRIBUTE((unused)) = type->u.hvector.blocklength;
677 intptr_t stride1 = type->u.hvector.stride;
678 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
679
680 int count2 = type->u.hvector.child->u.hvector.count;
681 int blocklength2 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.blocklength;
682 intptr_t stride2 = type->u.hvector.child->u.hvector.stride;
683 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.hvector.child->extent;
684
685 int count3 = type->u.hvector.child->u.hvector.child->u.hvector.count;
686 int blocklength3 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.child->u.hvector.blocklength;
687 intptr_t stride3 = type->u.hvector.child->u.hvector.child->u.hvector.stride;
688 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.child->extent;
689
690 uintptr_t idx = 0;
691 for (int i = 0; i < count; i++) {
692 for (int j1 = 0; j1 < count1; j1++) {
693 for (int k1 = 0; k1 < blocklength1; k1++) {
694 for (int j2 = 0; j2 < count2; j2++) {
695 for (int k2 = 0; k2 < blocklength2; k2++) {
696 for (int j3 = 0; j3 < count3; j3++) {
697 for (int k3 = 0; k3 < 1; k3++) {
698 *((int8_t *) (void *) (dbuf + i * extent + j1 * stride1 + k1 * extent2 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t))) = *((const int8_t *) (const void *) (sbuf + idx));
699 idx += sizeof(int8_t);
700 }
701 }
702 }
703 }
704 }
705 }
706 }
707
708 return rc;
709 }
710
yaksuri_seqi_pack_hvector_hvector_hvector_blklen_2_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)711 int yaksuri_seqi_pack_hvector_hvector_hvector_blklen_2_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
712 {
713 int rc = YAKSA_SUCCESS;
714 const char *restrict sbuf = (const char *) inbuf;
715 char *restrict dbuf = (char *) outbuf;
716 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
717
718 int count1 = type->u.hvector.count;
719 int blocklength1 ATTRIBUTE((unused)) = type->u.hvector.blocklength;
720 intptr_t stride1 = type->u.hvector.stride;
721 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
722
723 int count2 = type->u.hvector.child->u.hvector.count;
724 int blocklength2 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.blocklength;
725 intptr_t stride2 = type->u.hvector.child->u.hvector.stride;
726 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.hvector.child->extent;
727
728 int count3 = type->u.hvector.child->u.hvector.child->u.hvector.count;
729 int blocklength3 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.child->u.hvector.blocklength;
730 intptr_t stride3 = type->u.hvector.child->u.hvector.child->u.hvector.stride;
731 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.child->extent;
732
733 uintptr_t idx = 0;
734 for (int i = 0; i < count; i++) {
735 for (int j1 = 0; j1 < count1; j1++) {
736 for (int k1 = 0; k1 < blocklength1; k1++) {
737 for (int j2 = 0; j2 < count2; j2++) {
738 for (int k2 = 0; k2 < blocklength2; k2++) {
739 for (int j3 = 0; j3 < count3; j3++) {
740 for (int k3 = 0; k3 < 2; k3++) {
741 *((int8_t *) (void *) (dbuf + idx)) = *((const int8_t *) (const void *) (sbuf + i * extent + j1 * stride1 + k1 * extent2 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t)));
742 idx += sizeof(int8_t);
743 }
744 }
745 }
746 }
747 }
748 }
749 }
750
751 return rc;
752 }
753
yaksuri_seqi_unpack_hvector_hvector_hvector_blklen_2_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)754 int yaksuri_seqi_unpack_hvector_hvector_hvector_blklen_2_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
755 {
756 int rc = YAKSA_SUCCESS;
757 const char *restrict sbuf = (const char *) inbuf;
758 char *restrict dbuf = (char *) outbuf;
759 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
760
761 int count1 = type->u.hvector.count;
762 int blocklength1 ATTRIBUTE((unused)) = type->u.hvector.blocklength;
763 intptr_t stride1 = type->u.hvector.stride;
764 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
765
766 int count2 = type->u.hvector.child->u.hvector.count;
767 int blocklength2 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.blocklength;
768 intptr_t stride2 = type->u.hvector.child->u.hvector.stride;
769 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.hvector.child->extent;
770
771 int count3 = type->u.hvector.child->u.hvector.child->u.hvector.count;
772 int blocklength3 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.child->u.hvector.blocklength;
773 intptr_t stride3 = type->u.hvector.child->u.hvector.child->u.hvector.stride;
774 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.child->extent;
775
776 uintptr_t idx = 0;
777 for (int i = 0; i < count; i++) {
778 for (int j1 = 0; j1 < count1; j1++) {
779 for (int k1 = 0; k1 < blocklength1; k1++) {
780 for (int j2 = 0; j2 < count2; j2++) {
781 for (int k2 = 0; k2 < blocklength2; k2++) {
782 for (int j3 = 0; j3 < count3; j3++) {
783 for (int k3 = 0; k3 < 2; k3++) {
784 *((int8_t *) (void *) (dbuf + i * extent + j1 * stride1 + k1 * extent2 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t))) = *((const int8_t *) (const void *) (sbuf + idx));
785 idx += sizeof(int8_t);
786 }
787 }
788 }
789 }
790 }
791 }
792 }
793
794 return rc;
795 }
796
yaksuri_seqi_pack_hvector_hvector_hvector_blklen_3_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)797 int yaksuri_seqi_pack_hvector_hvector_hvector_blklen_3_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
798 {
799 int rc = YAKSA_SUCCESS;
800 const char *restrict sbuf = (const char *) inbuf;
801 char *restrict dbuf = (char *) outbuf;
802 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
803
804 int count1 = type->u.hvector.count;
805 int blocklength1 ATTRIBUTE((unused)) = type->u.hvector.blocklength;
806 intptr_t stride1 = type->u.hvector.stride;
807 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
808
809 int count2 = type->u.hvector.child->u.hvector.count;
810 int blocklength2 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.blocklength;
811 intptr_t stride2 = type->u.hvector.child->u.hvector.stride;
812 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.hvector.child->extent;
813
814 int count3 = type->u.hvector.child->u.hvector.child->u.hvector.count;
815 int blocklength3 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.child->u.hvector.blocklength;
816 intptr_t stride3 = type->u.hvector.child->u.hvector.child->u.hvector.stride;
817 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.child->extent;
818
819 uintptr_t idx = 0;
820 for (int i = 0; i < count; i++) {
821 for (int j1 = 0; j1 < count1; j1++) {
822 for (int k1 = 0; k1 < blocklength1; k1++) {
823 for (int j2 = 0; j2 < count2; j2++) {
824 for (int k2 = 0; k2 < blocklength2; k2++) {
825 for (int j3 = 0; j3 < count3; j3++) {
826 for (int k3 = 0; k3 < 3; k3++) {
827 *((int8_t *) (void *) (dbuf + idx)) = *((const int8_t *) (const void *) (sbuf + i * extent + j1 * stride1 + k1 * extent2 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t)));
828 idx += sizeof(int8_t);
829 }
830 }
831 }
832 }
833 }
834 }
835 }
836
837 return rc;
838 }
839
yaksuri_seqi_unpack_hvector_hvector_hvector_blklen_3_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)840 int yaksuri_seqi_unpack_hvector_hvector_hvector_blklen_3_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
841 {
842 int rc = YAKSA_SUCCESS;
843 const char *restrict sbuf = (const char *) inbuf;
844 char *restrict dbuf = (char *) outbuf;
845 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
846
847 int count1 = type->u.hvector.count;
848 int blocklength1 ATTRIBUTE((unused)) = type->u.hvector.blocklength;
849 intptr_t stride1 = type->u.hvector.stride;
850 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
851
852 int count2 = type->u.hvector.child->u.hvector.count;
853 int blocklength2 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.blocklength;
854 intptr_t stride2 = type->u.hvector.child->u.hvector.stride;
855 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.hvector.child->extent;
856
857 int count3 = type->u.hvector.child->u.hvector.child->u.hvector.count;
858 int blocklength3 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.child->u.hvector.blocklength;
859 intptr_t stride3 = type->u.hvector.child->u.hvector.child->u.hvector.stride;
860 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.child->extent;
861
862 uintptr_t idx = 0;
863 for (int i = 0; i < count; i++) {
864 for (int j1 = 0; j1 < count1; j1++) {
865 for (int k1 = 0; k1 < blocklength1; k1++) {
866 for (int j2 = 0; j2 < count2; j2++) {
867 for (int k2 = 0; k2 < blocklength2; k2++) {
868 for (int j3 = 0; j3 < count3; j3++) {
869 for (int k3 = 0; k3 < 3; k3++) {
870 *((int8_t *) (void *) (dbuf + i * extent + j1 * stride1 + k1 * extent2 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t))) = *((const int8_t *) (const void *) (sbuf + idx));
871 idx += sizeof(int8_t);
872 }
873 }
874 }
875 }
876 }
877 }
878 }
879
880 return rc;
881 }
882
yaksuri_seqi_pack_hvector_hvector_hvector_blklen_4_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)883 int yaksuri_seqi_pack_hvector_hvector_hvector_blklen_4_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
884 {
885 int rc = YAKSA_SUCCESS;
886 const char *restrict sbuf = (const char *) inbuf;
887 char *restrict dbuf = (char *) outbuf;
888 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
889
890 int count1 = type->u.hvector.count;
891 int blocklength1 ATTRIBUTE((unused)) = type->u.hvector.blocklength;
892 intptr_t stride1 = type->u.hvector.stride;
893 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
894
895 int count2 = type->u.hvector.child->u.hvector.count;
896 int blocklength2 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.blocklength;
897 intptr_t stride2 = type->u.hvector.child->u.hvector.stride;
898 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.hvector.child->extent;
899
900 int count3 = type->u.hvector.child->u.hvector.child->u.hvector.count;
901 int blocklength3 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.child->u.hvector.blocklength;
902 intptr_t stride3 = type->u.hvector.child->u.hvector.child->u.hvector.stride;
903 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.child->extent;
904
905 uintptr_t idx = 0;
906 for (int i = 0; i < count; i++) {
907 for (int j1 = 0; j1 < count1; j1++) {
908 for (int k1 = 0; k1 < blocklength1; k1++) {
909 for (int j2 = 0; j2 < count2; j2++) {
910 for (int k2 = 0; k2 < blocklength2; k2++) {
911 for (int j3 = 0; j3 < count3; j3++) {
912 for (int k3 = 0; k3 < 4; k3++) {
913 *((int8_t *) (void *) (dbuf + idx)) = *((const int8_t *) (const void *) (sbuf + i * extent + j1 * stride1 + k1 * extent2 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t)));
914 idx += sizeof(int8_t);
915 }
916 }
917 }
918 }
919 }
920 }
921 }
922
923 return rc;
924 }
925
yaksuri_seqi_unpack_hvector_hvector_hvector_blklen_4_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)926 int yaksuri_seqi_unpack_hvector_hvector_hvector_blklen_4_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
927 {
928 int rc = YAKSA_SUCCESS;
929 const char *restrict sbuf = (const char *) inbuf;
930 char *restrict dbuf = (char *) outbuf;
931 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
932
933 int count1 = type->u.hvector.count;
934 int blocklength1 ATTRIBUTE((unused)) = type->u.hvector.blocklength;
935 intptr_t stride1 = type->u.hvector.stride;
936 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
937
938 int count2 = type->u.hvector.child->u.hvector.count;
939 int blocklength2 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.blocklength;
940 intptr_t stride2 = type->u.hvector.child->u.hvector.stride;
941 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.hvector.child->extent;
942
943 int count3 = type->u.hvector.child->u.hvector.child->u.hvector.count;
944 int blocklength3 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.child->u.hvector.blocklength;
945 intptr_t stride3 = type->u.hvector.child->u.hvector.child->u.hvector.stride;
946 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.child->extent;
947
948 uintptr_t idx = 0;
949 for (int i = 0; i < count; i++) {
950 for (int j1 = 0; j1 < count1; j1++) {
951 for (int k1 = 0; k1 < blocklength1; k1++) {
952 for (int j2 = 0; j2 < count2; j2++) {
953 for (int k2 = 0; k2 < blocklength2; k2++) {
954 for (int j3 = 0; j3 < count3; j3++) {
955 for (int k3 = 0; k3 < 4; k3++) {
956 *((int8_t *) (void *) (dbuf + i * extent + j1 * stride1 + k1 * extent2 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t))) = *((const int8_t *) (const void *) (sbuf + idx));
957 idx += sizeof(int8_t);
958 }
959 }
960 }
961 }
962 }
963 }
964 }
965
966 return rc;
967 }
968
yaksuri_seqi_pack_hvector_hvector_hvector_blklen_5_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)969 int yaksuri_seqi_pack_hvector_hvector_hvector_blklen_5_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
970 {
971 int rc = YAKSA_SUCCESS;
972 const char *restrict sbuf = (const char *) inbuf;
973 char *restrict dbuf = (char *) outbuf;
974 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
975
976 int count1 = type->u.hvector.count;
977 int blocklength1 ATTRIBUTE((unused)) = type->u.hvector.blocklength;
978 intptr_t stride1 = type->u.hvector.stride;
979 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
980
981 int count2 = type->u.hvector.child->u.hvector.count;
982 int blocklength2 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.blocklength;
983 intptr_t stride2 = type->u.hvector.child->u.hvector.stride;
984 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.hvector.child->extent;
985
986 int count3 = type->u.hvector.child->u.hvector.child->u.hvector.count;
987 int blocklength3 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.child->u.hvector.blocklength;
988 intptr_t stride3 = type->u.hvector.child->u.hvector.child->u.hvector.stride;
989 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.child->extent;
990
991 uintptr_t idx = 0;
992 for (int i = 0; i < count; i++) {
993 for (int j1 = 0; j1 < count1; j1++) {
994 for (int k1 = 0; k1 < blocklength1; k1++) {
995 for (int j2 = 0; j2 < count2; j2++) {
996 for (int k2 = 0; k2 < blocklength2; k2++) {
997 for (int j3 = 0; j3 < count3; j3++) {
998 for (int k3 = 0; k3 < 5; k3++) {
999 *((int8_t *) (void *) (dbuf + idx)) = *((const int8_t *) (const void *) (sbuf + i * extent + j1 * stride1 + k1 * extent2 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t)));
1000 idx += sizeof(int8_t);
1001 }
1002 }
1003 }
1004 }
1005 }
1006 }
1007 }
1008
1009 return rc;
1010 }
1011
yaksuri_seqi_unpack_hvector_hvector_hvector_blklen_5_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)1012 int yaksuri_seqi_unpack_hvector_hvector_hvector_blklen_5_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
1013 {
1014 int rc = YAKSA_SUCCESS;
1015 const char *restrict sbuf = (const char *) inbuf;
1016 char *restrict dbuf = (char *) outbuf;
1017 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
1018
1019 int count1 = type->u.hvector.count;
1020 int blocklength1 ATTRIBUTE((unused)) = type->u.hvector.blocklength;
1021 intptr_t stride1 = type->u.hvector.stride;
1022 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
1023
1024 int count2 = type->u.hvector.child->u.hvector.count;
1025 int blocklength2 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.blocklength;
1026 intptr_t stride2 = type->u.hvector.child->u.hvector.stride;
1027 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.hvector.child->extent;
1028
1029 int count3 = type->u.hvector.child->u.hvector.child->u.hvector.count;
1030 int blocklength3 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.child->u.hvector.blocklength;
1031 intptr_t stride3 = type->u.hvector.child->u.hvector.child->u.hvector.stride;
1032 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.child->extent;
1033
1034 uintptr_t idx = 0;
1035 for (int i = 0; i < count; i++) {
1036 for (int j1 = 0; j1 < count1; j1++) {
1037 for (int k1 = 0; k1 < blocklength1; k1++) {
1038 for (int j2 = 0; j2 < count2; j2++) {
1039 for (int k2 = 0; k2 < blocklength2; k2++) {
1040 for (int j3 = 0; j3 < count3; j3++) {
1041 for (int k3 = 0; k3 < 5; k3++) {
1042 *((int8_t *) (void *) (dbuf + i * extent + j1 * stride1 + k1 * extent2 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t))) = *((const int8_t *) (const void *) (sbuf + idx));
1043 idx += sizeof(int8_t);
1044 }
1045 }
1046 }
1047 }
1048 }
1049 }
1050 }
1051
1052 return rc;
1053 }
1054
yaksuri_seqi_pack_hvector_hvector_hvector_blklen_6_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)1055 int yaksuri_seqi_pack_hvector_hvector_hvector_blklen_6_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
1056 {
1057 int rc = YAKSA_SUCCESS;
1058 const char *restrict sbuf = (const char *) inbuf;
1059 char *restrict dbuf = (char *) outbuf;
1060 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
1061
1062 int count1 = type->u.hvector.count;
1063 int blocklength1 ATTRIBUTE((unused)) = type->u.hvector.blocklength;
1064 intptr_t stride1 = type->u.hvector.stride;
1065 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
1066
1067 int count2 = type->u.hvector.child->u.hvector.count;
1068 int blocklength2 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.blocklength;
1069 intptr_t stride2 = type->u.hvector.child->u.hvector.stride;
1070 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.hvector.child->extent;
1071
1072 int count3 = type->u.hvector.child->u.hvector.child->u.hvector.count;
1073 int blocklength3 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.child->u.hvector.blocklength;
1074 intptr_t stride3 = type->u.hvector.child->u.hvector.child->u.hvector.stride;
1075 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.child->extent;
1076
1077 uintptr_t idx = 0;
1078 for (int i = 0; i < count; i++) {
1079 for (int j1 = 0; j1 < count1; j1++) {
1080 for (int k1 = 0; k1 < blocklength1; k1++) {
1081 for (int j2 = 0; j2 < count2; j2++) {
1082 for (int k2 = 0; k2 < blocklength2; k2++) {
1083 for (int j3 = 0; j3 < count3; j3++) {
1084 for (int k3 = 0; k3 < 6; k3++) {
1085 *((int8_t *) (void *) (dbuf + idx)) = *((const int8_t *) (const void *) (sbuf + i * extent + j1 * stride1 + k1 * extent2 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t)));
1086 idx += sizeof(int8_t);
1087 }
1088 }
1089 }
1090 }
1091 }
1092 }
1093 }
1094
1095 return rc;
1096 }
1097
yaksuri_seqi_unpack_hvector_hvector_hvector_blklen_6_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)1098 int yaksuri_seqi_unpack_hvector_hvector_hvector_blklen_6_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
1099 {
1100 int rc = YAKSA_SUCCESS;
1101 const char *restrict sbuf = (const char *) inbuf;
1102 char *restrict dbuf = (char *) outbuf;
1103 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
1104
1105 int count1 = type->u.hvector.count;
1106 int blocklength1 ATTRIBUTE((unused)) = type->u.hvector.blocklength;
1107 intptr_t stride1 = type->u.hvector.stride;
1108 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
1109
1110 int count2 = type->u.hvector.child->u.hvector.count;
1111 int blocklength2 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.blocklength;
1112 intptr_t stride2 = type->u.hvector.child->u.hvector.stride;
1113 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.hvector.child->extent;
1114
1115 int count3 = type->u.hvector.child->u.hvector.child->u.hvector.count;
1116 int blocklength3 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.child->u.hvector.blocklength;
1117 intptr_t stride3 = type->u.hvector.child->u.hvector.child->u.hvector.stride;
1118 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.child->extent;
1119
1120 uintptr_t idx = 0;
1121 for (int i = 0; i < count; i++) {
1122 for (int j1 = 0; j1 < count1; j1++) {
1123 for (int k1 = 0; k1 < blocklength1; k1++) {
1124 for (int j2 = 0; j2 < count2; j2++) {
1125 for (int k2 = 0; k2 < blocklength2; k2++) {
1126 for (int j3 = 0; j3 < count3; j3++) {
1127 for (int k3 = 0; k3 < 6; k3++) {
1128 *((int8_t *) (void *) (dbuf + i * extent + j1 * stride1 + k1 * extent2 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t))) = *((const int8_t *) (const void *) (sbuf + idx));
1129 idx += sizeof(int8_t);
1130 }
1131 }
1132 }
1133 }
1134 }
1135 }
1136 }
1137
1138 return rc;
1139 }
1140
yaksuri_seqi_pack_hvector_hvector_hvector_blklen_7_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)1141 int yaksuri_seqi_pack_hvector_hvector_hvector_blklen_7_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
1142 {
1143 int rc = YAKSA_SUCCESS;
1144 const char *restrict sbuf = (const char *) inbuf;
1145 char *restrict dbuf = (char *) outbuf;
1146 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
1147
1148 int count1 = type->u.hvector.count;
1149 int blocklength1 ATTRIBUTE((unused)) = type->u.hvector.blocklength;
1150 intptr_t stride1 = type->u.hvector.stride;
1151 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
1152
1153 int count2 = type->u.hvector.child->u.hvector.count;
1154 int blocklength2 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.blocklength;
1155 intptr_t stride2 = type->u.hvector.child->u.hvector.stride;
1156 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.hvector.child->extent;
1157
1158 int count3 = type->u.hvector.child->u.hvector.child->u.hvector.count;
1159 int blocklength3 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.child->u.hvector.blocklength;
1160 intptr_t stride3 = type->u.hvector.child->u.hvector.child->u.hvector.stride;
1161 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.child->extent;
1162
1163 uintptr_t idx = 0;
1164 for (int i = 0; i < count; i++) {
1165 for (int j1 = 0; j1 < count1; j1++) {
1166 for (int k1 = 0; k1 < blocklength1; k1++) {
1167 for (int j2 = 0; j2 < count2; j2++) {
1168 for (int k2 = 0; k2 < blocklength2; k2++) {
1169 for (int j3 = 0; j3 < count3; j3++) {
1170 for (int k3 = 0; k3 < 7; k3++) {
1171 *((int8_t *) (void *) (dbuf + idx)) = *((const int8_t *) (const void *) (sbuf + i * extent + j1 * stride1 + k1 * extent2 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t)));
1172 idx += sizeof(int8_t);
1173 }
1174 }
1175 }
1176 }
1177 }
1178 }
1179 }
1180
1181 return rc;
1182 }
1183
yaksuri_seqi_unpack_hvector_hvector_hvector_blklen_7_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)1184 int yaksuri_seqi_unpack_hvector_hvector_hvector_blklen_7_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
1185 {
1186 int rc = YAKSA_SUCCESS;
1187 const char *restrict sbuf = (const char *) inbuf;
1188 char *restrict dbuf = (char *) outbuf;
1189 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
1190
1191 int count1 = type->u.hvector.count;
1192 int blocklength1 ATTRIBUTE((unused)) = type->u.hvector.blocklength;
1193 intptr_t stride1 = type->u.hvector.stride;
1194 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
1195
1196 int count2 = type->u.hvector.child->u.hvector.count;
1197 int blocklength2 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.blocklength;
1198 intptr_t stride2 = type->u.hvector.child->u.hvector.stride;
1199 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.hvector.child->extent;
1200
1201 int count3 = type->u.hvector.child->u.hvector.child->u.hvector.count;
1202 int blocklength3 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.child->u.hvector.blocklength;
1203 intptr_t stride3 = type->u.hvector.child->u.hvector.child->u.hvector.stride;
1204 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.child->extent;
1205
1206 uintptr_t idx = 0;
1207 for (int i = 0; i < count; i++) {
1208 for (int j1 = 0; j1 < count1; j1++) {
1209 for (int k1 = 0; k1 < blocklength1; k1++) {
1210 for (int j2 = 0; j2 < count2; j2++) {
1211 for (int k2 = 0; k2 < blocklength2; k2++) {
1212 for (int j3 = 0; j3 < count3; j3++) {
1213 for (int k3 = 0; k3 < 7; k3++) {
1214 *((int8_t *) (void *) (dbuf + i * extent + j1 * stride1 + k1 * extent2 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t))) = *((const int8_t *) (const void *) (sbuf + idx));
1215 idx += sizeof(int8_t);
1216 }
1217 }
1218 }
1219 }
1220 }
1221 }
1222 }
1223
1224 return rc;
1225 }
1226
yaksuri_seqi_pack_hvector_hvector_hvector_blklen_8_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)1227 int yaksuri_seqi_pack_hvector_hvector_hvector_blklen_8_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
1228 {
1229 int rc = YAKSA_SUCCESS;
1230 const char *restrict sbuf = (const char *) inbuf;
1231 char *restrict dbuf = (char *) outbuf;
1232 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
1233
1234 int count1 = type->u.hvector.count;
1235 int blocklength1 ATTRIBUTE((unused)) = type->u.hvector.blocklength;
1236 intptr_t stride1 = type->u.hvector.stride;
1237 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
1238
1239 int count2 = type->u.hvector.child->u.hvector.count;
1240 int blocklength2 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.blocklength;
1241 intptr_t stride2 = type->u.hvector.child->u.hvector.stride;
1242 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.hvector.child->extent;
1243
1244 int count3 = type->u.hvector.child->u.hvector.child->u.hvector.count;
1245 int blocklength3 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.child->u.hvector.blocklength;
1246 intptr_t stride3 = type->u.hvector.child->u.hvector.child->u.hvector.stride;
1247 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.child->extent;
1248
1249 uintptr_t idx = 0;
1250 for (int i = 0; i < count; i++) {
1251 for (int j1 = 0; j1 < count1; j1++) {
1252 for (int k1 = 0; k1 < blocklength1; k1++) {
1253 for (int j2 = 0; j2 < count2; j2++) {
1254 for (int k2 = 0; k2 < blocklength2; k2++) {
1255 for (int j3 = 0; j3 < count3; j3++) {
1256 for (int k3 = 0; k3 < 8; k3++) {
1257 *((int8_t *) (void *) (dbuf + idx)) = *((const int8_t *) (const void *) (sbuf + i * extent + j1 * stride1 + k1 * extent2 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t)));
1258 idx += sizeof(int8_t);
1259 }
1260 }
1261 }
1262 }
1263 }
1264 }
1265 }
1266
1267 return rc;
1268 }
1269
yaksuri_seqi_unpack_hvector_hvector_hvector_blklen_8_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)1270 int yaksuri_seqi_unpack_hvector_hvector_hvector_blklen_8_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
1271 {
1272 int rc = YAKSA_SUCCESS;
1273 const char *restrict sbuf = (const char *) inbuf;
1274 char *restrict dbuf = (char *) outbuf;
1275 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
1276
1277 int count1 = type->u.hvector.count;
1278 int blocklength1 ATTRIBUTE((unused)) = type->u.hvector.blocklength;
1279 intptr_t stride1 = type->u.hvector.stride;
1280 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
1281
1282 int count2 = type->u.hvector.child->u.hvector.count;
1283 int blocklength2 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.blocklength;
1284 intptr_t stride2 = type->u.hvector.child->u.hvector.stride;
1285 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.hvector.child->extent;
1286
1287 int count3 = type->u.hvector.child->u.hvector.child->u.hvector.count;
1288 int blocklength3 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.child->u.hvector.blocklength;
1289 intptr_t stride3 = type->u.hvector.child->u.hvector.child->u.hvector.stride;
1290 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.child->extent;
1291
1292 uintptr_t idx = 0;
1293 for (int i = 0; i < count; i++) {
1294 for (int j1 = 0; j1 < count1; j1++) {
1295 for (int k1 = 0; k1 < blocklength1; k1++) {
1296 for (int j2 = 0; j2 < count2; j2++) {
1297 for (int k2 = 0; k2 < blocklength2; k2++) {
1298 for (int j3 = 0; j3 < count3; j3++) {
1299 for (int k3 = 0; k3 < 8; k3++) {
1300 *((int8_t *) (void *) (dbuf + i * extent + j1 * stride1 + k1 * extent2 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t))) = *((const int8_t *) (const void *) (sbuf + idx));
1301 idx += sizeof(int8_t);
1302 }
1303 }
1304 }
1305 }
1306 }
1307 }
1308 }
1309
1310 return rc;
1311 }
1312
yaksuri_seqi_pack_hvector_hvector_hvector_blklen_generic_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)1313 int yaksuri_seqi_pack_hvector_hvector_hvector_blklen_generic_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
1314 {
1315 int rc = YAKSA_SUCCESS;
1316 const char *restrict sbuf = (const char *) inbuf;
1317 char *restrict dbuf = (char *) outbuf;
1318 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
1319
1320 int count1 = type->u.hvector.count;
1321 int blocklength1 ATTRIBUTE((unused)) = type->u.hvector.blocklength;
1322 intptr_t stride1 = type->u.hvector.stride;
1323 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
1324
1325 int count2 = type->u.hvector.child->u.hvector.count;
1326 int blocklength2 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.blocklength;
1327 intptr_t stride2 = type->u.hvector.child->u.hvector.stride;
1328 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.hvector.child->extent;
1329
1330 int count3 = type->u.hvector.child->u.hvector.child->u.hvector.count;
1331 int blocklength3 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.child->u.hvector.blocklength;
1332 intptr_t stride3 = type->u.hvector.child->u.hvector.child->u.hvector.stride;
1333 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.child->extent;
1334
1335 uintptr_t idx = 0;
1336 for (int i = 0; i < count; i++) {
1337 for (int j1 = 0; j1 < count1; j1++) {
1338 for (int k1 = 0; k1 < blocklength1; k1++) {
1339 for (int j2 = 0; j2 < count2; j2++) {
1340 for (int k2 = 0; k2 < blocklength2; k2++) {
1341 for (int j3 = 0; j3 < count3; j3++) {
1342 for (int k3 = 0; k3 < blocklength3; k3++) {
1343 *((int8_t *) (void *) (dbuf + idx)) = *((const int8_t *) (const void *) (sbuf + i * extent + j1 * stride1 + k1 * extent2 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t)));
1344 idx += sizeof(int8_t);
1345 }
1346 }
1347 }
1348 }
1349 }
1350 }
1351 }
1352
1353 return rc;
1354 }
1355
yaksuri_seqi_unpack_hvector_hvector_hvector_blklen_generic_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)1356 int yaksuri_seqi_unpack_hvector_hvector_hvector_blklen_generic_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
1357 {
1358 int rc = YAKSA_SUCCESS;
1359 const char *restrict sbuf = (const char *) inbuf;
1360 char *restrict dbuf = (char *) outbuf;
1361 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
1362
1363 int count1 = type->u.hvector.count;
1364 int blocklength1 ATTRIBUTE((unused)) = type->u.hvector.blocklength;
1365 intptr_t stride1 = type->u.hvector.stride;
1366 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
1367
1368 int count2 = type->u.hvector.child->u.hvector.count;
1369 int blocklength2 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.blocklength;
1370 intptr_t stride2 = type->u.hvector.child->u.hvector.stride;
1371 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.hvector.child->extent;
1372
1373 int count3 = type->u.hvector.child->u.hvector.child->u.hvector.count;
1374 int blocklength3 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.child->u.hvector.blocklength;
1375 intptr_t stride3 = type->u.hvector.child->u.hvector.child->u.hvector.stride;
1376 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.hvector.child->u.hvector.child->extent;
1377
1378 uintptr_t idx = 0;
1379 for (int i = 0; i < count; i++) {
1380 for (int j1 = 0; j1 < count1; j1++) {
1381 for (int k1 = 0; k1 < blocklength1; k1++) {
1382 for (int j2 = 0; j2 < count2; j2++) {
1383 for (int k2 = 0; k2 < blocklength2; k2++) {
1384 for (int j3 = 0; j3 < count3; j3++) {
1385 for (int k3 = 0; k3 < blocklength3; k3++) {
1386 *((int8_t *) (void *) (dbuf + i * extent + j1 * stride1 + k1 * extent2 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t))) = *((const int8_t *) (const void *) (sbuf + idx));
1387 idx += sizeof(int8_t);
1388 }
1389 }
1390 }
1391 }
1392 }
1393 }
1394 }
1395
1396 return rc;
1397 }
1398
yaksuri_seqi_pack_blkhindx_hvector_hvector_blklen_1_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)1399 int yaksuri_seqi_pack_blkhindx_hvector_hvector_blklen_1_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
1400 {
1401 int rc = YAKSA_SUCCESS;
1402 const char *restrict sbuf = (const char *) inbuf;
1403 char *restrict dbuf = (char *) outbuf;
1404 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
1405
1406 int count1 = type->u.blkhindx.count;
1407 int blocklength1 ATTRIBUTE((unused)) = type->u.blkhindx.blocklength;
1408 intptr_t *restrict array_of_displs1 = type->u.blkhindx.array_of_displs;
1409 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
1410
1411 int count2 = type->u.blkhindx.child->u.hvector.count;
1412 int blocklength2 ATTRIBUTE((unused)) = type->u.blkhindx.child->u.hvector.blocklength;
1413 intptr_t stride2 = type->u.blkhindx.child->u.hvector.stride;
1414 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.blkhindx.child->extent;
1415
1416 int count3 = type->u.blkhindx.child->u.hvector.child->u.hvector.count;
1417 int blocklength3 ATTRIBUTE((unused)) = type->u.blkhindx.child->u.hvector.child->u.hvector.blocklength;
1418 intptr_t stride3 = type->u.blkhindx.child->u.hvector.child->u.hvector.stride;
1419 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.blkhindx.child->u.hvector.child->extent;
1420
1421 uintptr_t idx = 0;
1422 for (int i = 0; i < count; i++) {
1423 for (int j1 = 0; j1 < count1; j1++) {
1424 for (int k1 = 0; k1 < blocklength1; k1++) {
1425 for (int j2 = 0; j2 < count2; j2++) {
1426 for (int k2 = 0; k2 < blocklength2; k2++) {
1427 for (int j3 = 0; j3 < count3; j3++) {
1428 for (int k3 = 0; k3 < 1; k3++) {
1429 *((int8_t *) (void *) (dbuf + idx)) = *((const int8_t *) (const void *) (sbuf + i * extent + array_of_displs1[j1] + k1 * extent2 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t)));
1430 idx += sizeof(int8_t);
1431 }
1432 }
1433 }
1434 }
1435 }
1436 }
1437 }
1438
1439 return rc;
1440 }
1441
yaksuri_seqi_unpack_blkhindx_hvector_hvector_blklen_1_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)1442 int yaksuri_seqi_unpack_blkhindx_hvector_hvector_blklen_1_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
1443 {
1444 int rc = YAKSA_SUCCESS;
1445 const char *restrict sbuf = (const char *) inbuf;
1446 char *restrict dbuf = (char *) outbuf;
1447 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
1448
1449 int count1 = type->u.blkhindx.count;
1450 int blocklength1 ATTRIBUTE((unused)) = type->u.blkhindx.blocklength;
1451 intptr_t *restrict array_of_displs1 = type->u.blkhindx.array_of_displs;
1452 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
1453
1454 int count2 = type->u.blkhindx.child->u.hvector.count;
1455 int blocklength2 ATTRIBUTE((unused)) = type->u.blkhindx.child->u.hvector.blocklength;
1456 intptr_t stride2 = type->u.blkhindx.child->u.hvector.stride;
1457 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.blkhindx.child->extent;
1458
1459 int count3 = type->u.blkhindx.child->u.hvector.child->u.hvector.count;
1460 int blocklength3 ATTRIBUTE((unused)) = type->u.blkhindx.child->u.hvector.child->u.hvector.blocklength;
1461 intptr_t stride3 = type->u.blkhindx.child->u.hvector.child->u.hvector.stride;
1462 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.blkhindx.child->u.hvector.child->extent;
1463
1464 uintptr_t idx = 0;
1465 for (int i = 0; i < count; i++) {
1466 for (int j1 = 0; j1 < count1; j1++) {
1467 for (int k1 = 0; k1 < blocklength1; k1++) {
1468 for (int j2 = 0; j2 < count2; j2++) {
1469 for (int k2 = 0; k2 < blocklength2; k2++) {
1470 for (int j3 = 0; j3 < count3; j3++) {
1471 for (int k3 = 0; k3 < 1; k3++) {
1472 *((int8_t *) (void *) (dbuf + i * extent + array_of_displs1[j1] + k1 * extent2 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t))) = *((const int8_t *) (const void *) (sbuf + idx));
1473 idx += sizeof(int8_t);
1474 }
1475 }
1476 }
1477 }
1478 }
1479 }
1480 }
1481
1482 return rc;
1483 }
1484
yaksuri_seqi_pack_blkhindx_hvector_hvector_blklen_2_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)1485 int yaksuri_seqi_pack_blkhindx_hvector_hvector_blklen_2_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
1486 {
1487 int rc = YAKSA_SUCCESS;
1488 const char *restrict sbuf = (const char *) inbuf;
1489 char *restrict dbuf = (char *) outbuf;
1490 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
1491
1492 int count1 = type->u.blkhindx.count;
1493 int blocklength1 ATTRIBUTE((unused)) = type->u.blkhindx.blocklength;
1494 intptr_t *restrict array_of_displs1 = type->u.blkhindx.array_of_displs;
1495 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
1496
1497 int count2 = type->u.blkhindx.child->u.hvector.count;
1498 int blocklength2 ATTRIBUTE((unused)) = type->u.blkhindx.child->u.hvector.blocklength;
1499 intptr_t stride2 = type->u.blkhindx.child->u.hvector.stride;
1500 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.blkhindx.child->extent;
1501
1502 int count3 = type->u.blkhindx.child->u.hvector.child->u.hvector.count;
1503 int blocklength3 ATTRIBUTE((unused)) = type->u.blkhindx.child->u.hvector.child->u.hvector.blocklength;
1504 intptr_t stride3 = type->u.blkhindx.child->u.hvector.child->u.hvector.stride;
1505 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.blkhindx.child->u.hvector.child->extent;
1506
1507 uintptr_t idx = 0;
1508 for (int i = 0; i < count; i++) {
1509 for (int j1 = 0; j1 < count1; j1++) {
1510 for (int k1 = 0; k1 < blocklength1; k1++) {
1511 for (int j2 = 0; j2 < count2; j2++) {
1512 for (int k2 = 0; k2 < blocklength2; k2++) {
1513 for (int j3 = 0; j3 < count3; j3++) {
1514 for (int k3 = 0; k3 < 2; k3++) {
1515 *((int8_t *) (void *) (dbuf + idx)) = *((const int8_t *) (const void *) (sbuf + i * extent + array_of_displs1[j1] + k1 * extent2 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t)));
1516 idx += sizeof(int8_t);
1517 }
1518 }
1519 }
1520 }
1521 }
1522 }
1523 }
1524
1525 return rc;
1526 }
1527
yaksuri_seqi_unpack_blkhindx_hvector_hvector_blklen_2_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)1528 int yaksuri_seqi_unpack_blkhindx_hvector_hvector_blklen_2_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
1529 {
1530 int rc = YAKSA_SUCCESS;
1531 const char *restrict sbuf = (const char *) inbuf;
1532 char *restrict dbuf = (char *) outbuf;
1533 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
1534
1535 int count1 = type->u.blkhindx.count;
1536 int blocklength1 ATTRIBUTE((unused)) = type->u.blkhindx.blocklength;
1537 intptr_t *restrict array_of_displs1 = type->u.blkhindx.array_of_displs;
1538 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
1539
1540 int count2 = type->u.blkhindx.child->u.hvector.count;
1541 int blocklength2 ATTRIBUTE((unused)) = type->u.blkhindx.child->u.hvector.blocklength;
1542 intptr_t stride2 = type->u.blkhindx.child->u.hvector.stride;
1543 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.blkhindx.child->extent;
1544
1545 int count3 = type->u.blkhindx.child->u.hvector.child->u.hvector.count;
1546 int blocklength3 ATTRIBUTE((unused)) = type->u.blkhindx.child->u.hvector.child->u.hvector.blocklength;
1547 intptr_t stride3 = type->u.blkhindx.child->u.hvector.child->u.hvector.stride;
1548 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.blkhindx.child->u.hvector.child->extent;
1549
1550 uintptr_t idx = 0;
1551 for (int i = 0; i < count; i++) {
1552 for (int j1 = 0; j1 < count1; j1++) {
1553 for (int k1 = 0; k1 < blocklength1; k1++) {
1554 for (int j2 = 0; j2 < count2; j2++) {
1555 for (int k2 = 0; k2 < blocklength2; k2++) {
1556 for (int j3 = 0; j3 < count3; j3++) {
1557 for (int k3 = 0; k3 < 2; k3++) {
1558 *((int8_t *) (void *) (dbuf + i * extent + array_of_displs1[j1] + k1 * extent2 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t))) = *((const int8_t *) (const void *) (sbuf + idx));
1559 idx += sizeof(int8_t);
1560 }
1561 }
1562 }
1563 }
1564 }
1565 }
1566 }
1567
1568 return rc;
1569 }
1570
yaksuri_seqi_pack_blkhindx_hvector_hvector_blklen_3_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)1571 int yaksuri_seqi_pack_blkhindx_hvector_hvector_blklen_3_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
1572 {
1573 int rc = YAKSA_SUCCESS;
1574 const char *restrict sbuf = (const char *) inbuf;
1575 char *restrict dbuf = (char *) outbuf;
1576 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
1577
1578 int count1 = type->u.blkhindx.count;
1579 int blocklength1 ATTRIBUTE((unused)) = type->u.blkhindx.blocklength;
1580 intptr_t *restrict array_of_displs1 = type->u.blkhindx.array_of_displs;
1581 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
1582
1583 int count2 = type->u.blkhindx.child->u.hvector.count;
1584 int blocklength2 ATTRIBUTE((unused)) = type->u.blkhindx.child->u.hvector.blocklength;
1585 intptr_t stride2 = type->u.blkhindx.child->u.hvector.stride;
1586 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.blkhindx.child->extent;
1587
1588 int count3 = type->u.blkhindx.child->u.hvector.child->u.hvector.count;
1589 int blocklength3 ATTRIBUTE((unused)) = type->u.blkhindx.child->u.hvector.child->u.hvector.blocklength;
1590 intptr_t stride3 = type->u.blkhindx.child->u.hvector.child->u.hvector.stride;
1591 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.blkhindx.child->u.hvector.child->extent;
1592
1593 uintptr_t idx = 0;
1594 for (int i = 0; i < count; i++) {
1595 for (int j1 = 0; j1 < count1; j1++) {
1596 for (int k1 = 0; k1 < blocklength1; k1++) {
1597 for (int j2 = 0; j2 < count2; j2++) {
1598 for (int k2 = 0; k2 < blocklength2; k2++) {
1599 for (int j3 = 0; j3 < count3; j3++) {
1600 for (int k3 = 0; k3 < 3; k3++) {
1601 *((int8_t *) (void *) (dbuf + idx)) = *((const int8_t *) (const void *) (sbuf + i * extent + array_of_displs1[j1] + k1 * extent2 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t)));
1602 idx += sizeof(int8_t);
1603 }
1604 }
1605 }
1606 }
1607 }
1608 }
1609 }
1610
1611 return rc;
1612 }
1613
yaksuri_seqi_unpack_blkhindx_hvector_hvector_blklen_3_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)1614 int yaksuri_seqi_unpack_blkhindx_hvector_hvector_blklen_3_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
1615 {
1616 int rc = YAKSA_SUCCESS;
1617 const char *restrict sbuf = (const char *) inbuf;
1618 char *restrict dbuf = (char *) outbuf;
1619 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
1620
1621 int count1 = type->u.blkhindx.count;
1622 int blocklength1 ATTRIBUTE((unused)) = type->u.blkhindx.blocklength;
1623 intptr_t *restrict array_of_displs1 = type->u.blkhindx.array_of_displs;
1624 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
1625
1626 int count2 = type->u.blkhindx.child->u.hvector.count;
1627 int blocklength2 ATTRIBUTE((unused)) = type->u.blkhindx.child->u.hvector.blocklength;
1628 intptr_t stride2 = type->u.blkhindx.child->u.hvector.stride;
1629 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.blkhindx.child->extent;
1630
1631 int count3 = type->u.blkhindx.child->u.hvector.child->u.hvector.count;
1632 int blocklength3 ATTRIBUTE((unused)) = type->u.blkhindx.child->u.hvector.child->u.hvector.blocklength;
1633 intptr_t stride3 = type->u.blkhindx.child->u.hvector.child->u.hvector.stride;
1634 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.blkhindx.child->u.hvector.child->extent;
1635
1636 uintptr_t idx = 0;
1637 for (int i = 0; i < count; i++) {
1638 for (int j1 = 0; j1 < count1; j1++) {
1639 for (int k1 = 0; k1 < blocklength1; k1++) {
1640 for (int j2 = 0; j2 < count2; j2++) {
1641 for (int k2 = 0; k2 < blocklength2; k2++) {
1642 for (int j3 = 0; j3 < count3; j3++) {
1643 for (int k3 = 0; k3 < 3; k3++) {
1644 *((int8_t *) (void *) (dbuf + i * extent + array_of_displs1[j1] + k1 * extent2 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t))) = *((const int8_t *) (const void *) (sbuf + idx));
1645 idx += sizeof(int8_t);
1646 }
1647 }
1648 }
1649 }
1650 }
1651 }
1652 }
1653
1654 return rc;
1655 }
1656
yaksuri_seqi_pack_blkhindx_hvector_hvector_blklen_4_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)1657 int yaksuri_seqi_pack_blkhindx_hvector_hvector_blklen_4_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
1658 {
1659 int rc = YAKSA_SUCCESS;
1660 const char *restrict sbuf = (const char *) inbuf;
1661 char *restrict dbuf = (char *) outbuf;
1662 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
1663
1664 int count1 = type->u.blkhindx.count;
1665 int blocklength1 ATTRIBUTE((unused)) = type->u.blkhindx.blocklength;
1666 intptr_t *restrict array_of_displs1 = type->u.blkhindx.array_of_displs;
1667 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
1668
1669 int count2 = type->u.blkhindx.child->u.hvector.count;
1670 int blocklength2 ATTRIBUTE((unused)) = type->u.blkhindx.child->u.hvector.blocklength;
1671 intptr_t stride2 = type->u.blkhindx.child->u.hvector.stride;
1672 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.blkhindx.child->extent;
1673
1674 int count3 = type->u.blkhindx.child->u.hvector.child->u.hvector.count;
1675 int blocklength3 ATTRIBUTE((unused)) = type->u.blkhindx.child->u.hvector.child->u.hvector.blocklength;
1676 intptr_t stride3 = type->u.blkhindx.child->u.hvector.child->u.hvector.stride;
1677 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.blkhindx.child->u.hvector.child->extent;
1678
1679 uintptr_t idx = 0;
1680 for (int i = 0; i < count; i++) {
1681 for (int j1 = 0; j1 < count1; j1++) {
1682 for (int k1 = 0; k1 < blocklength1; k1++) {
1683 for (int j2 = 0; j2 < count2; j2++) {
1684 for (int k2 = 0; k2 < blocklength2; k2++) {
1685 for (int j3 = 0; j3 < count3; j3++) {
1686 for (int k3 = 0; k3 < 4; k3++) {
1687 *((int8_t *) (void *) (dbuf + idx)) = *((const int8_t *) (const void *) (sbuf + i * extent + array_of_displs1[j1] + k1 * extent2 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t)));
1688 idx += sizeof(int8_t);
1689 }
1690 }
1691 }
1692 }
1693 }
1694 }
1695 }
1696
1697 return rc;
1698 }
1699
yaksuri_seqi_unpack_blkhindx_hvector_hvector_blklen_4_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)1700 int yaksuri_seqi_unpack_blkhindx_hvector_hvector_blklen_4_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
1701 {
1702 int rc = YAKSA_SUCCESS;
1703 const char *restrict sbuf = (const char *) inbuf;
1704 char *restrict dbuf = (char *) outbuf;
1705 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
1706
1707 int count1 = type->u.blkhindx.count;
1708 int blocklength1 ATTRIBUTE((unused)) = type->u.blkhindx.blocklength;
1709 intptr_t *restrict array_of_displs1 = type->u.blkhindx.array_of_displs;
1710 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
1711
1712 int count2 = type->u.blkhindx.child->u.hvector.count;
1713 int blocklength2 ATTRIBUTE((unused)) = type->u.blkhindx.child->u.hvector.blocklength;
1714 intptr_t stride2 = type->u.blkhindx.child->u.hvector.stride;
1715 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.blkhindx.child->extent;
1716
1717 int count3 = type->u.blkhindx.child->u.hvector.child->u.hvector.count;
1718 int blocklength3 ATTRIBUTE((unused)) = type->u.blkhindx.child->u.hvector.child->u.hvector.blocklength;
1719 intptr_t stride3 = type->u.blkhindx.child->u.hvector.child->u.hvector.stride;
1720 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.blkhindx.child->u.hvector.child->extent;
1721
1722 uintptr_t idx = 0;
1723 for (int i = 0; i < count; i++) {
1724 for (int j1 = 0; j1 < count1; j1++) {
1725 for (int k1 = 0; k1 < blocklength1; k1++) {
1726 for (int j2 = 0; j2 < count2; j2++) {
1727 for (int k2 = 0; k2 < blocklength2; k2++) {
1728 for (int j3 = 0; j3 < count3; j3++) {
1729 for (int k3 = 0; k3 < 4; k3++) {
1730 *((int8_t *) (void *) (dbuf + i * extent + array_of_displs1[j1] + k1 * extent2 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t))) = *((const int8_t *) (const void *) (sbuf + idx));
1731 idx += sizeof(int8_t);
1732 }
1733 }
1734 }
1735 }
1736 }
1737 }
1738 }
1739
1740 return rc;
1741 }
1742
yaksuri_seqi_pack_blkhindx_hvector_hvector_blklen_5_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)1743 int yaksuri_seqi_pack_blkhindx_hvector_hvector_blklen_5_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
1744 {
1745 int rc = YAKSA_SUCCESS;
1746 const char *restrict sbuf = (const char *) inbuf;
1747 char *restrict dbuf = (char *) outbuf;
1748 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
1749
1750 int count1 = type->u.blkhindx.count;
1751 int blocklength1 ATTRIBUTE((unused)) = type->u.blkhindx.blocklength;
1752 intptr_t *restrict array_of_displs1 = type->u.blkhindx.array_of_displs;
1753 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
1754
1755 int count2 = type->u.blkhindx.child->u.hvector.count;
1756 int blocklength2 ATTRIBUTE((unused)) = type->u.blkhindx.child->u.hvector.blocklength;
1757 intptr_t stride2 = type->u.blkhindx.child->u.hvector.stride;
1758 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.blkhindx.child->extent;
1759
1760 int count3 = type->u.blkhindx.child->u.hvector.child->u.hvector.count;
1761 int blocklength3 ATTRIBUTE((unused)) = type->u.blkhindx.child->u.hvector.child->u.hvector.blocklength;
1762 intptr_t stride3 = type->u.blkhindx.child->u.hvector.child->u.hvector.stride;
1763 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.blkhindx.child->u.hvector.child->extent;
1764
1765 uintptr_t idx = 0;
1766 for (int i = 0; i < count; i++) {
1767 for (int j1 = 0; j1 < count1; j1++) {
1768 for (int k1 = 0; k1 < blocklength1; k1++) {
1769 for (int j2 = 0; j2 < count2; j2++) {
1770 for (int k2 = 0; k2 < blocklength2; k2++) {
1771 for (int j3 = 0; j3 < count3; j3++) {
1772 for (int k3 = 0; k3 < 5; k3++) {
1773 *((int8_t *) (void *) (dbuf + idx)) = *((const int8_t *) (const void *) (sbuf + i * extent + array_of_displs1[j1] + k1 * extent2 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t)));
1774 idx += sizeof(int8_t);
1775 }
1776 }
1777 }
1778 }
1779 }
1780 }
1781 }
1782
1783 return rc;
1784 }
1785
yaksuri_seqi_unpack_blkhindx_hvector_hvector_blklen_5_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)1786 int yaksuri_seqi_unpack_blkhindx_hvector_hvector_blklen_5_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
1787 {
1788 int rc = YAKSA_SUCCESS;
1789 const char *restrict sbuf = (const char *) inbuf;
1790 char *restrict dbuf = (char *) outbuf;
1791 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
1792
1793 int count1 = type->u.blkhindx.count;
1794 int blocklength1 ATTRIBUTE((unused)) = type->u.blkhindx.blocklength;
1795 intptr_t *restrict array_of_displs1 = type->u.blkhindx.array_of_displs;
1796 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
1797
1798 int count2 = type->u.blkhindx.child->u.hvector.count;
1799 int blocklength2 ATTRIBUTE((unused)) = type->u.blkhindx.child->u.hvector.blocklength;
1800 intptr_t stride2 = type->u.blkhindx.child->u.hvector.stride;
1801 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.blkhindx.child->extent;
1802
1803 int count3 = type->u.blkhindx.child->u.hvector.child->u.hvector.count;
1804 int blocklength3 ATTRIBUTE((unused)) = type->u.blkhindx.child->u.hvector.child->u.hvector.blocklength;
1805 intptr_t stride3 = type->u.blkhindx.child->u.hvector.child->u.hvector.stride;
1806 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.blkhindx.child->u.hvector.child->extent;
1807
1808 uintptr_t idx = 0;
1809 for (int i = 0; i < count; i++) {
1810 for (int j1 = 0; j1 < count1; j1++) {
1811 for (int k1 = 0; k1 < blocklength1; k1++) {
1812 for (int j2 = 0; j2 < count2; j2++) {
1813 for (int k2 = 0; k2 < blocklength2; k2++) {
1814 for (int j3 = 0; j3 < count3; j3++) {
1815 for (int k3 = 0; k3 < 5; k3++) {
1816 *((int8_t *) (void *) (dbuf + i * extent + array_of_displs1[j1] + k1 * extent2 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t))) = *((const int8_t *) (const void *) (sbuf + idx));
1817 idx += sizeof(int8_t);
1818 }
1819 }
1820 }
1821 }
1822 }
1823 }
1824 }
1825
1826 return rc;
1827 }
1828
yaksuri_seqi_pack_blkhindx_hvector_hvector_blklen_6_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)1829 int yaksuri_seqi_pack_blkhindx_hvector_hvector_blklen_6_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
1830 {
1831 int rc = YAKSA_SUCCESS;
1832 const char *restrict sbuf = (const char *) inbuf;
1833 char *restrict dbuf = (char *) outbuf;
1834 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
1835
1836 int count1 = type->u.blkhindx.count;
1837 int blocklength1 ATTRIBUTE((unused)) = type->u.blkhindx.blocklength;
1838 intptr_t *restrict array_of_displs1 = type->u.blkhindx.array_of_displs;
1839 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
1840
1841 int count2 = type->u.blkhindx.child->u.hvector.count;
1842 int blocklength2 ATTRIBUTE((unused)) = type->u.blkhindx.child->u.hvector.blocklength;
1843 intptr_t stride2 = type->u.blkhindx.child->u.hvector.stride;
1844 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.blkhindx.child->extent;
1845
1846 int count3 = type->u.blkhindx.child->u.hvector.child->u.hvector.count;
1847 int blocklength3 ATTRIBUTE((unused)) = type->u.blkhindx.child->u.hvector.child->u.hvector.blocklength;
1848 intptr_t stride3 = type->u.blkhindx.child->u.hvector.child->u.hvector.stride;
1849 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.blkhindx.child->u.hvector.child->extent;
1850
1851 uintptr_t idx = 0;
1852 for (int i = 0; i < count; i++) {
1853 for (int j1 = 0; j1 < count1; j1++) {
1854 for (int k1 = 0; k1 < blocklength1; k1++) {
1855 for (int j2 = 0; j2 < count2; j2++) {
1856 for (int k2 = 0; k2 < blocklength2; k2++) {
1857 for (int j3 = 0; j3 < count3; j3++) {
1858 for (int k3 = 0; k3 < 6; k3++) {
1859 *((int8_t *) (void *) (dbuf + idx)) = *((const int8_t *) (const void *) (sbuf + i * extent + array_of_displs1[j1] + k1 * extent2 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t)));
1860 idx += sizeof(int8_t);
1861 }
1862 }
1863 }
1864 }
1865 }
1866 }
1867 }
1868
1869 return rc;
1870 }
1871
yaksuri_seqi_unpack_blkhindx_hvector_hvector_blklen_6_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)1872 int yaksuri_seqi_unpack_blkhindx_hvector_hvector_blklen_6_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
1873 {
1874 int rc = YAKSA_SUCCESS;
1875 const char *restrict sbuf = (const char *) inbuf;
1876 char *restrict dbuf = (char *) outbuf;
1877 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
1878
1879 int count1 = type->u.blkhindx.count;
1880 int blocklength1 ATTRIBUTE((unused)) = type->u.blkhindx.blocklength;
1881 intptr_t *restrict array_of_displs1 = type->u.blkhindx.array_of_displs;
1882 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
1883
1884 int count2 = type->u.blkhindx.child->u.hvector.count;
1885 int blocklength2 ATTRIBUTE((unused)) = type->u.blkhindx.child->u.hvector.blocklength;
1886 intptr_t stride2 = type->u.blkhindx.child->u.hvector.stride;
1887 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.blkhindx.child->extent;
1888
1889 int count3 = type->u.blkhindx.child->u.hvector.child->u.hvector.count;
1890 int blocklength3 ATTRIBUTE((unused)) = type->u.blkhindx.child->u.hvector.child->u.hvector.blocklength;
1891 intptr_t stride3 = type->u.blkhindx.child->u.hvector.child->u.hvector.stride;
1892 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.blkhindx.child->u.hvector.child->extent;
1893
1894 uintptr_t idx = 0;
1895 for (int i = 0; i < count; i++) {
1896 for (int j1 = 0; j1 < count1; j1++) {
1897 for (int k1 = 0; k1 < blocklength1; k1++) {
1898 for (int j2 = 0; j2 < count2; j2++) {
1899 for (int k2 = 0; k2 < blocklength2; k2++) {
1900 for (int j3 = 0; j3 < count3; j3++) {
1901 for (int k3 = 0; k3 < 6; k3++) {
1902 *((int8_t *) (void *) (dbuf + i * extent + array_of_displs1[j1] + k1 * extent2 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t))) = *((const int8_t *) (const void *) (sbuf + idx));
1903 idx += sizeof(int8_t);
1904 }
1905 }
1906 }
1907 }
1908 }
1909 }
1910 }
1911
1912 return rc;
1913 }
1914
yaksuri_seqi_pack_blkhindx_hvector_hvector_blklen_7_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)1915 int yaksuri_seqi_pack_blkhindx_hvector_hvector_blklen_7_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
1916 {
1917 int rc = YAKSA_SUCCESS;
1918 const char *restrict sbuf = (const char *) inbuf;
1919 char *restrict dbuf = (char *) outbuf;
1920 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
1921
1922 int count1 = type->u.blkhindx.count;
1923 int blocklength1 ATTRIBUTE((unused)) = type->u.blkhindx.blocklength;
1924 intptr_t *restrict array_of_displs1 = type->u.blkhindx.array_of_displs;
1925 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
1926
1927 int count2 = type->u.blkhindx.child->u.hvector.count;
1928 int blocklength2 ATTRIBUTE((unused)) = type->u.blkhindx.child->u.hvector.blocklength;
1929 intptr_t stride2 = type->u.blkhindx.child->u.hvector.stride;
1930 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.blkhindx.child->extent;
1931
1932 int count3 = type->u.blkhindx.child->u.hvector.child->u.hvector.count;
1933 int blocklength3 ATTRIBUTE((unused)) = type->u.blkhindx.child->u.hvector.child->u.hvector.blocklength;
1934 intptr_t stride3 = type->u.blkhindx.child->u.hvector.child->u.hvector.stride;
1935 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.blkhindx.child->u.hvector.child->extent;
1936
1937 uintptr_t idx = 0;
1938 for (int i = 0; i < count; i++) {
1939 for (int j1 = 0; j1 < count1; j1++) {
1940 for (int k1 = 0; k1 < blocklength1; k1++) {
1941 for (int j2 = 0; j2 < count2; j2++) {
1942 for (int k2 = 0; k2 < blocklength2; k2++) {
1943 for (int j3 = 0; j3 < count3; j3++) {
1944 for (int k3 = 0; k3 < 7; k3++) {
1945 *((int8_t *) (void *) (dbuf + idx)) = *((const int8_t *) (const void *) (sbuf + i * extent + array_of_displs1[j1] + k1 * extent2 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t)));
1946 idx += sizeof(int8_t);
1947 }
1948 }
1949 }
1950 }
1951 }
1952 }
1953 }
1954
1955 return rc;
1956 }
1957
yaksuri_seqi_unpack_blkhindx_hvector_hvector_blklen_7_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)1958 int yaksuri_seqi_unpack_blkhindx_hvector_hvector_blklen_7_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
1959 {
1960 int rc = YAKSA_SUCCESS;
1961 const char *restrict sbuf = (const char *) inbuf;
1962 char *restrict dbuf = (char *) outbuf;
1963 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
1964
1965 int count1 = type->u.blkhindx.count;
1966 int blocklength1 ATTRIBUTE((unused)) = type->u.blkhindx.blocklength;
1967 intptr_t *restrict array_of_displs1 = type->u.blkhindx.array_of_displs;
1968 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
1969
1970 int count2 = type->u.blkhindx.child->u.hvector.count;
1971 int blocklength2 ATTRIBUTE((unused)) = type->u.blkhindx.child->u.hvector.blocklength;
1972 intptr_t stride2 = type->u.blkhindx.child->u.hvector.stride;
1973 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.blkhindx.child->extent;
1974
1975 int count3 = type->u.blkhindx.child->u.hvector.child->u.hvector.count;
1976 int blocklength3 ATTRIBUTE((unused)) = type->u.blkhindx.child->u.hvector.child->u.hvector.blocklength;
1977 intptr_t stride3 = type->u.blkhindx.child->u.hvector.child->u.hvector.stride;
1978 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.blkhindx.child->u.hvector.child->extent;
1979
1980 uintptr_t idx = 0;
1981 for (int i = 0; i < count; i++) {
1982 for (int j1 = 0; j1 < count1; j1++) {
1983 for (int k1 = 0; k1 < blocklength1; k1++) {
1984 for (int j2 = 0; j2 < count2; j2++) {
1985 for (int k2 = 0; k2 < blocklength2; k2++) {
1986 for (int j3 = 0; j3 < count3; j3++) {
1987 for (int k3 = 0; k3 < 7; k3++) {
1988 *((int8_t *) (void *) (dbuf + i * extent + array_of_displs1[j1] + k1 * extent2 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t))) = *((const int8_t *) (const void *) (sbuf + idx));
1989 idx += sizeof(int8_t);
1990 }
1991 }
1992 }
1993 }
1994 }
1995 }
1996 }
1997
1998 return rc;
1999 }
2000
yaksuri_seqi_pack_blkhindx_hvector_hvector_blklen_8_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)2001 int yaksuri_seqi_pack_blkhindx_hvector_hvector_blklen_8_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
2002 {
2003 int rc = YAKSA_SUCCESS;
2004 const char *restrict sbuf = (const char *) inbuf;
2005 char *restrict dbuf = (char *) outbuf;
2006 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
2007
2008 int count1 = type->u.blkhindx.count;
2009 int blocklength1 ATTRIBUTE((unused)) = type->u.blkhindx.blocklength;
2010 intptr_t *restrict array_of_displs1 = type->u.blkhindx.array_of_displs;
2011 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
2012
2013 int count2 = type->u.blkhindx.child->u.hvector.count;
2014 int blocklength2 ATTRIBUTE((unused)) = type->u.blkhindx.child->u.hvector.blocklength;
2015 intptr_t stride2 = type->u.blkhindx.child->u.hvector.stride;
2016 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.blkhindx.child->extent;
2017
2018 int count3 = type->u.blkhindx.child->u.hvector.child->u.hvector.count;
2019 int blocklength3 ATTRIBUTE((unused)) = type->u.blkhindx.child->u.hvector.child->u.hvector.blocklength;
2020 intptr_t stride3 = type->u.blkhindx.child->u.hvector.child->u.hvector.stride;
2021 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.blkhindx.child->u.hvector.child->extent;
2022
2023 uintptr_t idx = 0;
2024 for (int i = 0; i < count; i++) {
2025 for (int j1 = 0; j1 < count1; j1++) {
2026 for (int k1 = 0; k1 < blocklength1; k1++) {
2027 for (int j2 = 0; j2 < count2; j2++) {
2028 for (int k2 = 0; k2 < blocklength2; k2++) {
2029 for (int j3 = 0; j3 < count3; j3++) {
2030 for (int k3 = 0; k3 < 8; k3++) {
2031 *((int8_t *) (void *) (dbuf + idx)) = *((const int8_t *) (const void *) (sbuf + i * extent + array_of_displs1[j1] + k1 * extent2 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t)));
2032 idx += sizeof(int8_t);
2033 }
2034 }
2035 }
2036 }
2037 }
2038 }
2039 }
2040
2041 return rc;
2042 }
2043
yaksuri_seqi_unpack_blkhindx_hvector_hvector_blklen_8_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)2044 int yaksuri_seqi_unpack_blkhindx_hvector_hvector_blklen_8_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
2045 {
2046 int rc = YAKSA_SUCCESS;
2047 const char *restrict sbuf = (const char *) inbuf;
2048 char *restrict dbuf = (char *) outbuf;
2049 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
2050
2051 int count1 = type->u.blkhindx.count;
2052 int blocklength1 ATTRIBUTE((unused)) = type->u.blkhindx.blocklength;
2053 intptr_t *restrict array_of_displs1 = type->u.blkhindx.array_of_displs;
2054 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
2055
2056 int count2 = type->u.blkhindx.child->u.hvector.count;
2057 int blocklength2 ATTRIBUTE((unused)) = type->u.blkhindx.child->u.hvector.blocklength;
2058 intptr_t stride2 = type->u.blkhindx.child->u.hvector.stride;
2059 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.blkhindx.child->extent;
2060
2061 int count3 = type->u.blkhindx.child->u.hvector.child->u.hvector.count;
2062 int blocklength3 ATTRIBUTE((unused)) = type->u.blkhindx.child->u.hvector.child->u.hvector.blocklength;
2063 intptr_t stride3 = type->u.blkhindx.child->u.hvector.child->u.hvector.stride;
2064 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.blkhindx.child->u.hvector.child->extent;
2065
2066 uintptr_t idx = 0;
2067 for (int i = 0; i < count; i++) {
2068 for (int j1 = 0; j1 < count1; j1++) {
2069 for (int k1 = 0; k1 < blocklength1; k1++) {
2070 for (int j2 = 0; j2 < count2; j2++) {
2071 for (int k2 = 0; k2 < blocklength2; k2++) {
2072 for (int j3 = 0; j3 < count3; j3++) {
2073 for (int k3 = 0; k3 < 8; k3++) {
2074 *((int8_t *) (void *) (dbuf + i * extent + array_of_displs1[j1] + k1 * extent2 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t))) = *((const int8_t *) (const void *) (sbuf + idx));
2075 idx += sizeof(int8_t);
2076 }
2077 }
2078 }
2079 }
2080 }
2081 }
2082 }
2083
2084 return rc;
2085 }
2086
yaksuri_seqi_pack_blkhindx_hvector_hvector_blklen_generic_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)2087 int yaksuri_seqi_pack_blkhindx_hvector_hvector_blklen_generic_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
2088 {
2089 int rc = YAKSA_SUCCESS;
2090 const char *restrict sbuf = (const char *) inbuf;
2091 char *restrict dbuf = (char *) outbuf;
2092 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
2093
2094 int count1 = type->u.blkhindx.count;
2095 int blocklength1 ATTRIBUTE((unused)) = type->u.blkhindx.blocklength;
2096 intptr_t *restrict array_of_displs1 = type->u.blkhindx.array_of_displs;
2097 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
2098
2099 int count2 = type->u.blkhindx.child->u.hvector.count;
2100 int blocklength2 ATTRIBUTE((unused)) = type->u.blkhindx.child->u.hvector.blocklength;
2101 intptr_t stride2 = type->u.blkhindx.child->u.hvector.stride;
2102 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.blkhindx.child->extent;
2103
2104 int count3 = type->u.blkhindx.child->u.hvector.child->u.hvector.count;
2105 int blocklength3 ATTRIBUTE((unused)) = type->u.blkhindx.child->u.hvector.child->u.hvector.blocklength;
2106 intptr_t stride3 = type->u.blkhindx.child->u.hvector.child->u.hvector.stride;
2107 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.blkhindx.child->u.hvector.child->extent;
2108
2109 uintptr_t idx = 0;
2110 for (int i = 0; i < count; i++) {
2111 for (int j1 = 0; j1 < count1; j1++) {
2112 for (int k1 = 0; k1 < blocklength1; k1++) {
2113 for (int j2 = 0; j2 < count2; j2++) {
2114 for (int k2 = 0; k2 < blocklength2; k2++) {
2115 for (int j3 = 0; j3 < count3; j3++) {
2116 for (int k3 = 0; k3 < blocklength3; k3++) {
2117 *((int8_t *) (void *) (dbuf + idx)) = *((const int8_t *) (const void *) (sbuf + i * extent + array_of_displs1[j1] + k1 * extent2 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t)));
2118 idx += sizeof(int8_t);
2119 }
2120 }
2121 }
2122 }
2123 }
2124 }
2125 }
2126
2127 return rc;
2128 }
2129
yaksuri_seqi_unpack_blkhindx_hvector_hvector_blklen_generic_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)2130 int yaksuri_seqi_unpack_blkhindx_hvector_hvector_blklen_generic_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
2131 {
2132 int rc = YAKSA_SUCCESS;
2133 const char *restrict sbuf = (const char *) inbuf;
2134 char *restrict dbuf = (char *) outbuf;
2135 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
2136
2137 int count1 = type->u.blkhindx.count;
2138 int blocklength1 ATTRIBUTE((unused)) = type->u.blkhindx.blocklength;
2139 intptr_t *restrict array_of_displs1 = type->u.blkhindx.array_of_displs;
2140 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
2141
2142 int count2 = type->u.blkhindx.child->u.hvector.count;
2143 int blocklength2 ATTRIBUTE((unused)) = type->u.blkhindx.child->u.hvector.blocklength;
2144 intptr_t stride2 = type->u.blkhindx.child->u.hvector.stride;
2145 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.blkhindx.child->extent;
2146
2147 int count3 = type->u.blkhindx.child->u.hvector.child->u.hvector.count;
2148 int blocklength3 ATTRIBUTE((unused)) = type->u.blkhindx.child->u.hvector.child->u.hvector.blocklength;
2149 intptr_t stride3 = type->u.blkhindx.child->u.hvector.child->u.hvector.stride;
2150 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.blkhindx.child->u.hvector.child->extent;
2151
2152 uintptr_t idx = 0;
2153 for (int i = 0; i < count; i++) {
2154 for (int j1 = 0; j1 < count1; j1++) {
2155 for (int k1 = 0; k1 < blocklength1; k1++) {
2156 for (int j2 = 0; j2 < count2; j2++) {
2157 for (int k2 = 0; k2 < blocklength2; k2++) {
2158 for (int j3 = 0; j3 < count3; j3++) {
2159 for (int k3 = 0; k3 < blocklength3; k3++) {
2160 *((int8_t *) (void *) (dbuf + i * extent + array_of_displs1[j1] + k1 * extent2 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t))) = *((const int8_t *) (const void *) (sbuf + idx));
2161 idx += sizeof(int8_t);
2162 }
2163 }
2164 }
2165 }
2166 }
2167 }
2168 }
2169
2170 return rc;
2171 }
2172
yaksuri_seqi_pack_hindexed_hvector_hvector_blklen_1_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)2173 int yaksuri_seqi_pack_hindexed_hvector_hvector_blklen_1_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
2174 {
2175 int rc = YAKSA_SUCCESS;
2176 const char *restrict sbuf = (const char *) inbuf;
2177 char *restrict dbuf = (char *) outbuf;
2178 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
2179
2180 int count1 = type->u.hindexed.count;
2181 int *restrict array_of_blocklengths1 = type->u.hindexed.array_of_blocklengths;
2182 intptr_t *restrict array_of_displs1 = type->u.hindexed.array_of_displs;
2183 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
2184
2185 int count2 = type->u.hindexed.child->u.hvector.count;
2186 int blocklength2 ATTRIBUTE((unused)) = type->u.hindexed.child->u.hvector.blocklength;
2187 intptr_t stride2 = type->u.hindexed.child->u.hvector.stride;
2188 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.hindexed.child->extent;
2189
2190 int count3 = type->u.hindexed.child->u.hvector.child->u.hvector.count;
2191 int blocklength3 ATTRIBUTE((unused)) = type->u.hindexed.child->u.hvector.child->u.hvector.blocklength;
2192 intptr_t stride3 = type->u.hindexed.child->u.hvector.child->u.hvector.stride;
2193 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.hindexed.child->u.hvector.child->extent;
2194
2195 uintptr_t idx = 0;
2196 for (int i = 0; i < count; i++) {
2197 for (int j1 = 0; j1 < count1; j1++) {
2198 for (int k1 = 0; k1 < array_of_blocklengths1[j1]; k1++) {
2199 for (int j2 = 0; j2 < count2; j2++) {
2200 for (int k2 = 0; k2 < blocklength2; k2++) {
2201 for (int j3 = 0; j3 < count3; j3++) {
2202 for (int k3 = 0; k3 < 1; k3++) {
2203 *((int8_t *) (void *) (dbuf + idx)) = *((const int8_t *) (const void *) (sbuf + i * extent + array_of_displs1[j1] + k1 * extent2 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t)));
2204 idx += sizeof(int8_t);
2205 }
2206 }
2207 }
2208 }
2209 }
2210 }
2211 }
2212
2213 return rc;
2214 }
2215
yaksuri_seqi_unpack_hindexed_hvector_hvector_blklen_1_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)2216 int yaksuri_seqi_unpack_hindexed_hvector_hvector_blklen_1_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
2217 {
2218 int rc = YAKSA_SUCCESS;
2219 const char *restrict sbuf = (const char *) inbuf;
2220 char *restrict dbuf = (char *) outbuf;
2221 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
2222
2223 int count1 = type->u.hindexed.count;
2224 int *restrict array_of_blocklengths1 = type->u.hindexed.array_of_blocklengths;
2225 intptr_t *restrict array_of_displs1 = type->u.hindexed.array_of_displs;
2226 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
2227
2228 int count2 = type->u.hindexed.child->u.hvector.count;
2229 int blocklength2 ATTRIBUTE((unused)) = type->u.hindexed.child->u.hvector.blocklength;
2230 intptr_t stride2 = type->u.hindexed.child->u.hvector.stride;
2231 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.hindexed.child->extent;
2232
2233 int count3 = type->u.hindexed.child->u.hvector.child->u.hvector.count;
2234 int blocklength3 ATTRIBUTE((unused)) = type->u.hindexed.child->u.hvector.child->u.hvector.blocklength;
2235 intptr_t stride3 = type->u.hindexed.child->u.hvector.child->u.hvector.stride;
2236 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.hindexed.child->u.hvector.child->extent;
2237
2238 uintptr_t idx = 0;
2239 for (int i = 0; i < count; i++) {
2240 for (int j1 = 0; j1 < count1; j1++) {
2241 for (int k1 = 0; k1 < array_of_blocklengths1[j1]; k1++) {
2242 for (int j2 = 0; j2 < count2; j2++) {
2243 for (int k2 = 0; k2 < blocklength2; k2++) {
2244 for (int j3 = 0; j3 < count3; j3++) {
2245 for (int k3 = 0; k3 < 1; k3++) {
2246 *((int8_t *) (void *) (dbuf + i * extent + array_of_displs1[j1] + k1 * extent2 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t))) = *((const int8_t *) (const void *) (sbuf + idx));
2247 idx += sizeof(int8_t);
2248 }
2249 }
2250 }
2251 }
2252 }
2253 }
2254 }
2255
2256 return rc;
2257 }
2258
yaksuri_seqi_pack_hindexed_hvector_hvector_blklen_2_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)2259 int yaksuri_seqi_pack_hindexed_hvector_hvector_blklen_2_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
2260 {
2261 int rc = YAKSA_SUCCESS;
2262 const char *restrict sbuf = (const char *) inbuf;
2263 char *restrict dbuf = (char *) outbuf;
2264 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
2265
2266 int count1 = type->u.hindexed.count;
2267 int *restrict array_of_blocklengths1 = type->u.hindexed.array_of_blocklengths;
2268 intptr_t *restrict array_of_displs1 = type->u.hindexed.array_of_displs;
2269 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
2270
2271 int count2 = type->u.hindexed.child->u.hvector.count;
2272 int blocklength2 ATTRIBUTE((unused)) = type->u.hindexed.child->u.hvector.blocklength;
2273 intptr_t stride2 = type->u.hindexed.child->u.hvector.stride;
2274 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.hindexed.child->extent;
2275
2276 int count3 = type->u.hindexed.child->u.hvector.child->u.hvector.count;
2277 int blocklength3 ATTRIBUTE((unused)) = type->u.hindexed.child->u.hvector.child->u.hvector.blocklength;
2278 intptr_t stride3 = type->u.hindexed.child->u.hvector.child->u.hvector.stride;
2279 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.hindexed.child->u.hvector.child->extent;
2280
2281 uintptr_t idx = 0;
2282 for (int i = 0; i < count; i++) {
2283 for (int j1 = 0; j1 < count1; j1++) {
2284 for (int k1 = 0; k1 < array_of_blocklengths1[j1]; k1++) {
2285 for (int j2 = 0; j2 < count2; j2++) {
2286 for (int k2 = 0; k2 < blocklength2; k2++) {
2287 for (int j3 = 0; j3 < count3; j3++) {
2288 for (int k3 = 0; k3 < 2; k3++) {
2289 *((int8_t *) (void *) (dbuf + idx)) = *((const int8_t *) (const void *) (sbuf + i * extent + array_of_displs1[j1] + k1 * extent2 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t)));
2290 idx += sizeof(int8_t);
2291 }
2292 }
2293 }
2294 }
2295 }
2296 }
2297 }
2298
2299 return rc;
2300 }
2301
yaksuri_seqi_unpack_hindexed_hvector_hvector_blklen_2_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)2302 int yaksuri_seqi_unpack_hindexed_hvector_hvector_blklen_2_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
2303 {
2304 int rc = YAKSA_SUCCESS;
2305 const char *restrict sbuf = (const char *) inbuf;
2306 char *restrict dbuf = (char *) outbuf;
2307 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
2308
2309 int count1 = type->u.hindexed.count;
2310 int *restrict array_of_blocklengths1 = type->u.hindexed.array_of_blocklengths;
2311 intptr_t *restrict array_of_displs1 = type->u.hindexed.array_of_displs;
2312 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
2313
2314 int count2 = type->u.hindexed.child->u.hvector.count;
2315 int blocklength2 ATTRIBUTE((unused)) = type->u.hindexed.child->u.hvector.blocklength;
2316 intptr_t stride2 = type->u.hindexed.child->u.hvector.stride;
2317 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.hindexed.child->extent;
2318
2319 int count3 = type->u.hindexed.child->u.hvector.child->u.hvector.count;
2320 int blocklength3 ATTRIBUTE((unused)) = type->u.hindexed.child->u.hvector.child->u.hvector.blocklength;
2321 intptr_t stride3 = type->u.hindexed.child->u.hvector.child->u.hvector.stride;
2322 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.hindexed.child->u.hvector.child->extent;
2323
2324 uintptr_t idx = 0;
2325 for (int i = 0; i < count; i++) {
2326 for (int j1 = 0; j1 < count1; j1++) {
2327 for (int k1 = 0; k1 < array_of_blocklengths1[j1]; k1++) {
2328 for (int j2 = 0; j2 < count2; j2++) {
2329 for (int k2 = 0; k2 < blocklength2; k2++) {
2330 for (int j3 = 0; j3 < count3; j3++) {
2331 for (int k3 = 0; k3 < 2; k3++) {
2332 *((int8_t *) (void *) (dbuf + i * extent + array_of_displs1[j1] + k1 * extent2 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t))) = *((const int8_t *) (const void *) (sbuf + idx));
2333 idx += sizeof(int8_t);
2334 }
2335 }
2336 }
2337 }
2338 }
2339 }
2340 }
2341
2342 return rc;
2343 }
2344
yaksuri_seqi_pack_hindexed_hvector_hvector_blklen_3_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)2345 int yaksuri_seqi_pack_hindexed_hvector_hvector_blklen_3_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
2346 {
2347 int rc = YAKSA_SUCCESS;
2348 const char *restrict sbuf = (const char *) inbuf;
2349 char *restrict dbuf = (char *) outbuf;
2350 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
2351
2352 int count1 = type->u.hindexed.count;
2353 int *restrict array_of_blocklengths1 = type->u.hindexed.array_of_blocklengths;
2354 intptr_t *restrict array_of_displs1 = type->u.hindexed.array_of_displs;
2355 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
2356
2357 int count2 = type->u.hindexed.child->u.hvector.count;
2358 int blocklength2 ATTRIBUTE((unused)) = type->u.hindexed.child->u.hvector.blocklength;
2359 intptr_t stride2 = type->u.hindexed.child->u.hvector.stride;
2360 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.hindexed.child->extent;
2361
2362 int count3 = type->u.hindexed.child->u.hvector.child->u.hvector.count;
2363 int blocklength3 ATTRIBUTE((unused)) = type->u.hindexed.child->u.hvector.child->u.hvector.blocklength;
2364 intptr_t stride3 = type->u.hindexed.child->u.hvector.child->u.hvector.stride;
2365 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.hindexed.child->u.hvector.child->extent;
2366
2367 uintptr_t idx = 0;
2368 for (int i = 0; i < count; i++) {
2369 for (int j1 = 0; j1 < count1; j1++) {
2370 for (int k1 = 0; k1 < array_of_blocklengths1[j1]; k1++) {
2371 for (int j2 = 0; j2 < count2; j2++) {
2372 for (int k2 = 0; k2 < blocklength2; k2++) {
2373 for (int j3 = 0; j3 < count3; j3++) {
2374 for (int k3 = 0; k3 < 3; k3++) {
2375 *((int8_t *) (void *) (dbuf + idx)) = *((const int8_t *) (const void *) (sbuf + i * extent + array_of_displs1[j1] + k1 * extent2 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t)));
2376 idx += sizeof(int8_t);
2377 }
2378 }
2379 }
2380 }
2381 }
2382 }
2383 }
2384
2385 return rc;
2386 }
2387
yaksuri_seqi_unpack_hindexed_hvector_hvector_blklen_3_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)2388 int yaksuri_seqi_unpack_hindexed_hvector_hvector_blklen_3_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
2389 {
2390 int rc = YAKSA_SUCCESS;
2391 const char *restrict sbuf = (const char *) inbuf;
2392 char *restrict dbuf = (char *) outbuf;
2393 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
2394
2395 int count1 = type->u.hindexed.count;
2396 int *restrict array_of_blocklengths1 = type->u.hindexed.array_of_blocklengths;
2397 intptr_t *restrict array_of_displs1 = type->u.hindexed.array_of_displs;
2398 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
2399
2400 int count2 = type->u.hindexed.child->u.hvector.count;
2401 int blocklength2 ATTRIBUTE((unused)) = type->u.hindexed.child->u.hvector.blocklength;
2402 intptr_t stride2 = type->u.hindexed.child->u.hvector.stride;
2403 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.hindexed.child->extent;
2404
2405 int count3 = type->u.hindexed.child->u.hvector.child->u.hvector.count;
2406 int blocklength3 ATTRIBUTE((unused)) = type->u.hindexed.child->u.hvector.child->u.hvector.blocklength;
2407 intptr_t stride3 = type->u.hindexed.child->u.hvector.child->u.hvector.stride;
2408 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.hindexed.child->u.hvector.child->extent;
2409
2410 uintptr_t idx = 0;
2411 for (int i = 0; i < count; i++) {
2412 for (int j1 = 0; j1 < count1; j1++) {
2413 for (int k1 = 0; k1 < array_of_blocklengths1[j1]; k1++) {
2414 for (int j2 = 0; j2 < count2; j2++) {
2415 for (int k2 = 0; k2 < blocklength2; k2++) {
2416 for (int j3 = 0; j3 < count3; j3++) {
2417 for (int k3 = 0; k3 < 3; k3++) {
2418 *((int8_t *) (void *) (dbuf + i * extent + array_of_displs1[j1] + k1 * extent2 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t))) = *((const int8_t *) (const void *) (sbuf + idx));
2419 idx += sizeof(int8_t);
2420 }
2421 }
2422 }
2423 }
2424 }
2425 }
2426 }
2427
2428 return rc;
2429 }
2430
yaksuri_seqi_pack_hindexed_hvector_hvector_blklen_4_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)2431 int yaksuri_seqi_pack_hindexed_hvector_hvector_blklen_4_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
2432 {
2433 int rc = YAKSA_SUCCESS;
2434 const char *restrict sbuf = (const char *) inbuf;
2435 char *restrict dbuf = (char *) outbuf;
2436 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
2437
2438 int count1 = type->u.hindexed.count;
2439 int *restrict array_of_blocklengths1 = type->u.hindexed.array_of_blocklengths;
2440 intptr_t *restrict array_of_displs1 = type->u.hindexed.array_of_displs;
2441 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
2442
2443 int count2 = type->u.hindexed.child->u.hvector.count;
2444 int blocklength2 ATTRIBUTE((unused)) = type->u.hindexed.child->u.hvector.blocklength;
2445 intptr_t stride2 = type->u.hindexed.child->u.hvector.stride;
2446 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.hindexed.child->extent;
2447
2448 int count3 = type->u.hindexed.child->u.hvector.child->u.hvector.count;
2449 int blocklength3 ATTRIBUTE((unused)) = type->u.hindexed.child->u.hvector.child->u.hvector.blocklength;
2450 intptr_t stride3 = type->u.hindexed.child->u.hvector.child->u.hvector.stride;
2451 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.hindexed.child->u.hvector.child->extent;
2452
2453 uintptr_t idx = 0;
2454 for (int i = 0; i < count; i++) {
2455 for (int j1 = 0; j1 < count1; j1++) {
2456 for (int k1 = 0; k1 < array_of_blocklengths1[j1]; k1++) {
2457 for (int j2 = 0; j2 < count2; j2++) {
2458 for (int k2 = 0; k2 < blocklength2; k2++) {
2459 for (int j3 = 0; j3 < count3; j3++) {
2460 for (int k3 = 0; k3 < 4; k3++) {
2461 *((int8_t *) (void *) (dbuf + idx)) = *((const int8_t *) (const void *) (sbuf + i * extent + array_of_displs1[j1] + k1 * extent2 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t)));
2462 idx += sizeof(int8_t);
2463 }
2464 }
2465 }
2466 }
2467 }
2468 }
2469 }
2470
2471 return rc;
2472 }
2473
yaksuri_seqi_unpack_hindexed_hvector_hvector_blklen_4_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)2474 int yaksuri_seqi_unpack_hindexed_hvector_hvector_blklen_4_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
2475 {
2476 int rc = YAKSA_SUCCESS;
2477 const char *restrict sbuf = (const char *) inbuf;
2478 char *restrict dbuf = (char *) outbuf;
2479 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
2480
2481 int count1 = type->u.hindexed.count;
2482 int *restrict array_of_blocklengths1 = type->u.hindexed.array_of_blocklengths;
2483 intptr_t *restrict array_of_displs1 = type->u.hindexed.array_of_displs;
2484 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
2485
2486 int count2 = type->u.hindexed.child->u.hvector.count;
2487 int blocklength2 ATTRIBUTE((unused)) = type->u.hindexed.child->u.hvector.blocklength;
2488 intptr_t stride2 = type->u.hindexed.child->u.hvector.stride;
2489 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.hindexed.child->extent;
2490
2491 int count3 = type->u.hindexed.child->u.hvector.child->u.hvector.count;
2492 int blocklength3 ATTRIBUTE((unused)) = type->u.hindexed.child->u.hvector.child->u.hvector.blocklength;
2493 intptr_t stride3 = type->u.hindexed.child->u.hvector.child->u.hvector.stride;
2494 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.hindexed.child->u.hvector.child->extent;
2495
2496 uintptr_t idx = 0;
2497 for (int i = 0; i < count; i++) {
2498 for (int j1 = 0; j1 < count1; j1++) {
2499 for (int k1 = 0; k1 < array_of_blocklengths1[j1]; k1++) {
2500 for (int j2 = 0; j2 < count2; j2++) {
2501 for (int k2 = 0; k2 < blocklength2; k2++) {
2502 for (int j3 = 0; j3 < count3; j3++) {
2503 for (int k3 = 0; k3 < 4; k3++) {
2504 *((int8_t *) (void *) (dbuf + i * extent + array_of_displs1[j1] + k1 * extent2 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t))) = *((const int8_t *) (const void *) (sbuf + idx));
2505 idx += sizeof(int8_t);
2506 }
2507 }
2508 }
2509 }
2510 }
2511 }
2512 }
2513
2514 return rc;
2515 }
2516
yaksuri_seqi_pack_hindexed_hvector_hvector_blklen_5_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)2517 int yaksuri_seqi_pack_hindexed_hvector_hvector_blklen_5_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
2518 {
2519 int rc = YAKSA_SUCCESS;
2520 const char *restrict sbuf = (const char *) inbuf;
2521 char *restrict dbuf = (char *) outbuf;
2522 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
2523
2524 int count1 = type->u.hindexed.count;
2525 int *restrict array_of_blocklengths1 = type->u.hindexed.array_of_blocklengths;
2526 intptr_t *restrict array_of_displs1 = type->u.hindexed.array_of_displs;
2527 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
2528
2529 int count2 = type->u.hindexed.child->u.hvector.count;
2530 int blocklength2 ATTRIBUTE((unused)) = type->u.hindexed.child->u.hvector.blocklength;
2531 intptr_t stride2 = type->u.hindexed.child->u.hvector.stride;
2532 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.hindexed.child->extent;
2533
2534 int count3 = type->u.hindexed.child->u.hvector.child->u.hvector.count;
2535 int blocklength3 ATTRIBUTE((unused)) = type->u.hindexed.child->u.hvector.child->u.hvector.blocklength;
2536 intptr_t stride3 = type->u.hindexed.child->u.hvector.child->u.hvector.stride;
2537 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.hindexed.child->u.hvector.child->extent;
2538
2539 uintptr_t idx = 0;
2540 for (int i = 0; i < count; i++) {
2541 for (int j1 = 0; j1 < count1; j1++) {
2542 for (int k1 = 0; k1 < array_of_blocklengths1[j1]; k1++) {
2543 for (int j2 = 0; j2 < count2; j2++) {
2544 for (int k2 = 0; k2 < blocklength2; k2++) {
2545 for (int j3 = 0; j3 < count3; j3++) {
2546 for (int k3 = 0; k3 < 5; k3++) {
2547 *((int8_t *) (void *) (dbuf + idx)) = *((const int8_t *) (const void *) (sbuf + i * extent + array_of_displs1[j1] + k1 * extent2 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t)));
2548 idx += sizeof(int8_t);
2549 }
2550 }
2551 }
2552 }
2553 }
2554 }
2555 }
2556
2557 return rc;
2558 }
2559
yaksuri_seqi_unpack_hindexed_hvector_hvector_blklen_5_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)2560 int yaksuri_seqi_unpack_hindexed_hvector_hvector_blklen_5_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
2561 {
2562 int rc = YAKSA_SUCCESS;
2563 const char *restrict sbuf = (const char *) inbuf;
2564 char *restrict dbuf = (char *) outbuf;
2565 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
2566
2567 int count1 = type->u.hindexed.count;
2568 int *restrict array_of_blocklengths1 = type->u.hindexed.array_of_blocklengths;
2569 intptr_t *restrict array_of_displs1 = type->u.hindexed.array_of_displs;
2570 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
2571
2572 int count2 = type->u.hindexed.child->u.hvector.count;
2573 int blocklength2 ATTRIBUTE((unused)) = type->u.hindexed.child->u.hvector.blocklength;
2574 intptr_t stride2 = type->u.hindexed.child->u.hvector.stride;
2575 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.hindexed.child->extent;
2576
2577 int count3 = type->u.hindexed.child->u.hvector.child->u.hvector.count;
2578 int blocklength3 ATTRIBUTE((unused)) = type->u.hindexed.child->u.hvector.child->u.hvector.blocklength;
2579 intptr_t stride3 = type->u.hindexed.child->u.hvector.child->u.hvector.stride;
2580 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.hindexed.child->u.hvector.child->extent;
2581
2582 uintptr_t idx = 0;
2583 for (int i = 0; i < count; i++) {
2584 for (int j1 = 0; j1 < count1; j1++) {
2585 for (int k1 = 0; k1 < array_of_blocklengths1[j1]; k1++) {
2586 for (int j2 = 0; j2 < count2; j2++) {
2587 for (int k2 = 0; k2 < blocklength2; k2++) {
2588 for (int j3 = 0; j3 < count3; j3++) {
2589 for (int k3 = 0; k3 < 5; k3++) {
2590 *((int8_t *) (void *) (dbuf + i * extent + array_of_displs1[j1] + k1 * extent2 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t))) = *((const int8_t *) (const void *) (sbuf + idx));
2591 idx += sizeof(int8_t);
2592 }
2593 }
2594 }
2595 }
2596 }
2597 }
2598 }
2599
2600 return rc;
2601 }
2602
yaksuri_seqi_pack_hindexed_hvector_hvector_blklen_6_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)2603 int yaksuri_seqi_pack_hindexed_hvector_hvector_blklen_6_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
2604 {
2605 int rc = YAKSA_SUCCESS;
2606 const char *restrict sbuf = (const char *) inbuf;
2607 char *restrict dbuf = (char *) outbuf;
2608 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
2609
2610 int count1 = type->u.hindexed.count;
2611 int *restrict array_of_blocklengths1 = type->u.hindexed.array_of_blocklengths;
2612 intptr_t *restrict array_of_displs1 = type->u.hindexed.array_of_displs;
2613 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
2614
2615 int count2 = type->u.hindexed.child->u.hvector.count;
2616 int blocklength2 ATTRIBUTE((unused)) = type->u.hindexed.child->u.hvector.blocklength;
2617 intptr_t stride2 = type->u.hindexed.child->u.hvector.stride;
2618 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.hindexed.child->extent;
2619
2620 int count3 = type->u.hindexed.child->u.hvector.child->u.hvector.count;
2621 int blocklength3 ATTRIBUTE((unused)) = type->u.hindexed.child->u.hvector.child->u.hvector.blocklength;
2622 intptr_t stride3 = type->u.hindexed.child->u.hvector.child->u.hvector.stride;
2623 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.hindexed.child->u.hvector.child->extent;
2624
2625 uintptr_t idx = 0;
2626 for (int i = 0; i < count; i++) {
2627 for (int j1 = 0; j1 < count1; j1++) {
2628 for (int k1 = 0; k1 < array_of_blocklengths1[j1]; k1++) {
2629 for (int j2 = 0; j2 < count2; j2++) {
2630 for (int k2 = 0; k2 < blocklength2; k2++) {
2631 for (int j3 = 0; j3 < count3; j3++) {
2632 for (int k3 = 0; k3 < 6; k3++) {
2633 *((int8_t *) (void *) (dbuf + idx)) = *((const int8_t *) (const void *) (sbuf + i * extent + array_of_displs1[j1] + k1 * extent2 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t)));
2634 idx += sizeof(int8_t);
2635 }
2636 }
2637 }
2638 }
2639 }
2640 }
2641 }
2642
2643 return rc;
2644 }
2645
yaksuri_seqi_unpack_hindexed_hvector_hvector_blklen_6_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)2646 int yaksuri_seqi_unpack_hindexed_hvector_hvector_blklen_6_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
2647 {
2648 int rc = YAKSA_SUCCESS;
2649 const char *restrict sbuf = (const char *) inbuf;
2650 char *restrict dbuf = (char *) outbuf;
2651 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
2652
2653 int count1 = type->u.hindexed.count;
2654 int *restrict array_of_blocklengths1 = type->u.hindexed.array_of_blocklengths;
2655 intptr_t *restrict array_of_displs1 = type->u.hindexed.array_of_displs;
2656 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
2657
2658 int count2 = type->u.hindexed.child->u.hvector.count;
2659 int blocklength2 ATTRIBUTE((unused)) = type->u.hindexed.child->u.hvector.blocklength;
2660 intptr_t stride2 = type->u.hindexed.child->u.hvector.stride;
2661 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.hindexed.child->extent;
2662
2663 int count3 = type->u.hindexed.child->u.hvector.child->u.hvector.count;
2664 int blocklength3 ATTRIBUTE((unused)) = type->u.hindexed.child->u.hvector.child->u.hvector.blocklength;
2665 intptr_t stride3 = type->u.hindexed.child->u.hvector.child->u.hvector.stride;
2666 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.hindexed.child->u.hvector.child->extent;
2667
2668 uintptr_t idx = 0;
2669 for (int i = 0; i < count; i++) {
2670 for (int j1 = 0; j1 < count1; j1++) {
2671 for (int k1 = 0; k1 < array_of_blocklengths1[j1]; k1++) {
2672 for (int j2 = 0; j2 < count2; j2++) {
2673 for (int k2 = 0; k2 < blocklength2; k2++) {
2674 for (int j3 = 0; j3 < count3; j3++) {
2675 for (int k3 = 0; k3 < 6; k3++) {
2676 *((int8_t *) (void *) (dbuf + i * extent + array_of_displs1[j1] + k1 * extent2 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t))) = *((const int8_t *) (const void *) (sbuf + idx));
2677 idx += sizeof(int8_t);
2678 }
2679 }
2680 }
2681 }
2682 }
2683 }
2684 }
2685
2686 return rc;
2687 }
2688
yaksuri_seqi_pack_hindexed_hvector_hvector_blklen_7_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)2689 int yaksuri_seqi_pack_hindexed_hvector_hvector_blklen_7_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
2690 {
2691 int rc = YAKSA_SUCCESS;
2692 const char *restrict sbuf = (const char *) inbuf;
2693 char *restrict dbuf = (char *) outbuf;
2694 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
2695
2696 int count1 = type->u.hindexed.count;
2697 int *restrict array_of_blocklengths1 = type->u.hindexed.array_of_blocklengths;
2698 intptr_t *restrict array_of_displs1 = type->u.hindexed.array_of_displs;
2699 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
2700
2701 int count2 = type->u.hindexed.child->u.hvector.count;
2702 int blocklength2 ATTRIBUTE((unused)) = type->u.hindexed.child->u.hvector.blocklength;
2703 intptr_t stride2 = type->u.hindexed.child->u.hvector.stride;
2704 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.hindexed.child->extent;
2705
2706 int count3 = type->u.hindexed.child->u.hvector.child->u.hvector.count;
2707 int blocklength3 ATTRIBUTE((unused)) = type->u.hindexed.child->u.hvector.child->u.hvector.blocklength;
2708 intptr_t stride3 = type->u.hindexed.child->u.hvector.child->u.hvector.stride;
2709 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.hindexed.child->u.hvector.child->extent;
2710
2711 uintptr_t idx = 0;
2712 for (int i = 0; i < count; i++) {
2713 for (int j1 = 0; j1 < count1; j1++) {
2714 for (int k1 = 0; k1 < array_of_blocklengths1[j1]; k1++) {
2715 for (int j2 = 0; j2 < count2; j2++) {
2716 for (int k2 = 0; k2 < blocklength2; k2++) {
2717 for (int j3 = 0; j3 < count3; j3++) {
2718 for (int k3 = 0; k3 < 7; k3++) {
2719 *((int8_t *) (void *) (dbuf + idx)) = *((const int8_t *) (const void *) (sbuf + i * extent + array_of_displs1[j1] + k1 * extent2 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t)));
2720 idx += sizeof(int8_t);
2721 }
2722 }
2723 }
2724 }
2725 }
2726 }
2727 }
2728
2729 return rc;
2730 }
2731
yaksuri_seqi_unpack_hindexed_hvector_hvector_blklen_7_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)2732 int yaksuri_seqi_unpack_hindexed_hvector_hvector_blklen_7_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
2733 {
2734 int rc = YAKSA_SUCCESS;
2735 const char *restrict sbuf = (const char *) inbuf;
2736 char *restrict dbuf = (char *) outbuf;
2737 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
2738
2739 int count1 = type->u.hindexed.count;
2740 int *restrict array_of_blocklengths1 = type->u.hindexed.array_of_blocklengths;
2741 intptr_t *restrict array_of_displs1 = type->u.hindexed.array_of_displs;
2742 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
2743
2744 int count2 = type->u.hindexed.child->u.hvector.count;
2745 int blocklength2 ATTRIBUTE((unused)) = type->u.hindexed.child->u.hvector.blocklength;
2746 intptr_t stride2 = type->u.hindexed.child->u.hvector.stride;
2747 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.hindexed.child->extent;
2748
2749 int count3 = type->u.hindexed.child->u.hvector.child->u.hvector.count;
2750 int blocklength3 ATTRIBUTE((unused)) = type->u.hindexed.child->u.hvector.child->u.hvector.blocklength;
2751 intptr_t stride3 = type->u.hindexed.child->u.hvector.child->u.hvector.stride;
2752 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.hindexed.child->u.hvector.child->extent;
2753
2754 uintptr_t idx = 0;
2755 for (int i = 0; i < count; i++) {
2756 for (int j1 = 0; j1 < count1; j1++) {
2757 for (int k1 = 0; k1 < array_of_blocklengths1[j1]; k1++) {
2758 for (int j2 = 0; j2 < count2; j2++) {
2759 for (int k2 = 0; k2 < blocklength2; k2++) {
2760 for (int j3 = 0; j3 < count3; j3++) {
2761 for (int k3 = 0; k3 < 7; k3++) {
2762 *((int8_t *) (void *) (dbuf + i * extent + array_of_displs1[j1] + k1 * extent2 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t))) = *((const int8_t *) (const void *) (sbuf + idx));
2763 idx += sizeof(int8_t);
2764 }
2765 }
2766 }
2767 }
2768 }
2769 }
2770 }
2771
2772 return rc;
2773 }
2774
yaksuri_seqi_pack_hindexed_hvector_hvector_blklen_8_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)2775 int yaksuri_seqi_pack_hindexed_hvector_hvector_blklen_8_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
2776 {
2777 int rc = YAKSA_SUCCESS;
2778 const char *restrict sbuf = (const char *) inbuf;
2779 char *restrict dbuf = (char *) outbuf;
2780 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
2781
2782 int count1 = type->u.hindexed.count;
2783 int *restrict array_of_blocklengths1 = type->u.hindexed.array_of_blocklengths;
2784 intptr_t *restrict array_of_displs1 = type->u.hindexed.array_of_displs;
2785 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
2786
2787 int count2 = type->u.hindexed.child->u.hvector.count;
2788 int blocklength2 ATTRIBUTE((unused)) = type->u.hindexed.child->u.hvector.blocklength;
2789 intptr_t stride2 = type->u.hindexed.child->u.hvector.stride;
2790 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.hindexed.child->extent;
2791
2792 int count3 = type->u.hindexed.child->u.hvector.child->u.hvector.count;
2793 int blocklength3 ATTRIBUTE((unused)) = type->u.hindexed.child->u.hvector.child->u.hvector.blocklength;
2794 intptr_t stride3 = type->u.hindexed.child->u.hvector.child->u.hvector.stride;
2795 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.hindexed.child->u.hvector.child->extent;
2796
2797 uintptr_t idx = 0;
2798 for (int i = 0; i < count; i++) {
2799 for (int j1 = 0; j1 < count1; j1++) {
2800 for (int k1 = 0; k1 < array_of_blocklengths1[j1]; k1++) {
2801 for (int j2 = 0; j2 < count2; j2++) {
2802 for (int k2 = 0; k2 < blocklength2; k2++) {
2803 for (int j3 = 0; j3 < count3; j3++) {
2804 for (int k3 = 0; k3 < 8; k3++) {
2805 *((int8_t *) (void *) (dbuf + idx)) = *((const int8_t *) (const void *) (sbuf + i * extent + array_of_displs1[j1] + k1 * extent2 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t)));
2806 idx += sizeof(int8_t);
2807 }
2808 }
2809 }
2810 }
2811 }
2812 }
2813 }
2814
2815 return rc;
2816 }
2817
yaksuri_seqi_unpack_hindexed_hvector_hvector_blklen_8_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)2818 int yaksuri_seqi_unpack_hindexed_hvector_hvector_blklen_8_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
2819 {
2820 int rc = YAKSA_SUCCESS;
2821 const char *restrict sbuf = (const char *) inbuf;
2822 char *restrict dbuf = (char *) outbuf;
2823 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
2824
2825 int count1 = type->u.hindexed.count;
2826 int *restrict array_of_blocklengths1 = type->u.hindexed.array_of_blocklengths;
2827 intptr_t *restrict array_of_displs1 = type->u.hindexed.array_of_displs;
2828 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
2829
2830 int count2 = type->u.hindexed.child->u.hvector.count;
2831 int blocklength2 ATTRIBUTE((unused)) = type->u.hindexed.child->u.hvector.blocklength;
2832 intptr_t stride2 = type->u.hindexed.child->u.hvector.stride;
2833 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.hindexed.child->extent;
2834
2835 int count3 = type->u.hindexed.child->u.hvector.child->u.hvector.count;
2836 int blocklength3 ATTRIBUTE((unused)) = type->u.hindexed.child->u.hvector.child->u.hvector.blocklength;
2837 intptr_t stride3 = type->u.hindexed.child->u.hvector.child->u.hvector.stride;
2838 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.hindexed.child->u.hvector.child->extent;
2839
2840 uintptr_t idx = 0;
2841 for (int i = 0; i < count; i++) {
2842 for (int j1 = 0; j1 < count1; j1++) {
2843 for (int k1 = 0; k1 < array_of_blocklengths1[j1]; k1++) {
2844 for (int j2 = 0; j2 < count2; j2++) {
2845 for (int k2 = 0; k2 < blocklength2; k2++) {
2846 for (int j3 = 0; j3 < count3; j3++) {
2847 for (int k3 = 0; k3 < 8; k3++) {
2848 *((int8_t *) (void *) (dbuf + i * extent + array_of_displs1[j1] + k1 * extent2 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t))) = *((const int8_t *) (const void *) (sbuf + idx));
2849 idx += sizeof(int8_t);
2850 }
2851 }
2852 }
2853 }
2854 }
2855 }
2856 }
2857
2858 return rc;
2859 }
2860
yaksuri_seqi_pack_hindexed_hvector_hvector_blklen_generic_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)2861 int yaksuri_seqi_pack_hindexed_hvector_hvector_blklen_generic_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
2862 {
2863 int rc = YAKSA_SUCCESS;
2864 const char *restrict sbuf = (const char *) inbuf;
2865 char *restrict dbuf = (char *) outbuf;
2866 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
2867
2868 int count1 = type->u.hindexed.count;
2869 int *restrict array_of_blocklengths1 = type->u.hindexed.array_of_blocklengths;
2870 intptr_t *restrict array_of_displs1 = type->u.hindexed.array_of_displs;
2871 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
2872
2873 int count2 = type->u.hindexed.child->u.hvector.count;
2874 int blocklength2 ATTRIBUTE((unused)) = type->u.hindexed.child->u.hvector.blocklength;
2875 intptr_t stride2 = type->u.hindexed.child->u.hvector.stride;
2876 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.hindexed.child->extent;
2877
2878 int count3 = type->u.hindexed.child->u.hvector.child->u.hvector.count;
2879 int blocklength3 ATTRIBUTE((unused)) = type->u.hindexed.child->u.hvector.child->u.hvector.blocklength;
2880 intptr_t stride3 = type->u.hindexed.child->u.hvector.child->u.hvector.stride;
2881 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.hindexed.child->u.hvector.child->extent;
2882
2883 uintptr_t idx = 0;
2884 for (int i = 0; i < count; i++) {
2885 for (int j1 = 0; j1 < count1; j1++) {
2886 for (int k1 = 0; k1 < array_of_blocklengths1[j1]; k1++) {
2887 for (int j2 = 0; j2 < count2; j2++) {
2888 for (int k2 = 0; k2 < blocklength2; k2++) {
2889 for (int j3 = 0; j3 < count3; j3++) {
2890 for (int k3 = 0; k3 < blocklength3; k3++) {
2891 *((int8_t *) (void *) (dbuf + idx)) = *((const int8_t *) (const void *) (sbuf + i * extent + array_of_displs1[j1] + k1 * extent2 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t)));
2892 idx += sizeof(int8_t);
2893 }
2894 }
2895 }
2896 }
2897 }
2898 }
2899 }
2900
2901 return rc;
2902 }
2903
yaksuri_seqi_unpack_hindexed_hvector_hvector_blklen_generic_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)2904 int yaksuri_seqi_unpack_hindexed_hvector_hvector_blklen_generic_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
2905 {
2906 int rc = YAKSA_SUCCESS;
2907 const char *restrict sbuf = (const char *) inbuf;
2908 char *restrict dbuf = (char *) outbuf;
2909 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
2910
2911 int count1 = type->u.hindexed.count;
2912 int *restrict array_of_blocklengths1 = type->u.hindexed.array_of_blocklengths;
2913 intptr_t *restrict array_of_displs1 = type->u.hindexed.array_of_displs;
2914 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
2915
2916 int count2 = type->u.hindexed.child->u.hvector.count;
2917 int blocklength2 ATTRIBUTE((unused)) = type->u.hindexed.child->u.hvector.blocklength;
2918 intptr_t stride2 = type->u.hindexed.child->u.hvector.stride;
2919 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.hindexed.child->extent;
2920
2921 int count3 = type->u.hindexed.child->u.hvector.child->u.hvector.count;
2922 int blocklength3 ATTRIBUTE((unused)) = type->u.hindexed.child->u.hvector.child->u.hvector.blocklength;
2923 intptr_t stride3 = type->u.hindexed.child->u.hvector.child->u.hvector.stride;
2924 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.hindexed.child->u.hvector.child->extent;
2925
2926 uintptr_t idx = 0;
2927 for (int i = 0; i < count; i++) {
2928 for (int j1 = 0; j1 < count1; j1++) {
2929 for (int k1 = 0; k1 < array_of_blocklengths1[j1]; k1++) {
2930 for (int j2 = 0; j2 < count2; j2++) {
2931 for (int k2 = 0; k2 < blocklength2; k2++) {
2932 for (int j3 = 0; j3 < count3; j3++) {
2933 for (int k3 = 0; k3 < blocklength3; k3++) {
2934 *((int8_t *) (void *) (dbuf + i * extent + array_of_displs1[j1] + k1 * extent2 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t))) = *((const int8_t *) (const void *) (sbuf + idx));
2935 idx += sizeof(int8_t);
2936 }
2937 }
2938 }
2939 }
2940 }
2941 }
2942 }
2943
2944 return rc;
2945 }
2946
yaksuri_seqi_pack_contig_hvector_hvector_blklen_1_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)2947 int yaksuri_seqi_pack_contig_hvector_hvector_blklen_1_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
2948 {
2949 int rc = YAKSA_SUCCESS;
2950 const char *restrict sbuf = (const char *) inbuf;
2951 char *restrict dbuf = (char *) outbuf;
2952 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
2953
2954 int count1 = type->u.contig.count;
2955 intptr_t stride1 = type->u.contig.child->extent;
2956 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
2957
2958 int count2 = type->u.contig.child->u.hvector.count;
2959 int blocklength2 ATTRIBUTE((unused)) = type->u.contig.child->u.hvector.blocklength;
2960 intptr_t stride2 = type->u.contig.child->u.hvector.stride;
2961 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.contig.child->extent;
2962
2963 int count3 = type->u.contig.child->u.hvector.child->u.hvector.count;
2964 int blocklength3 ATTRIBUTE((unused)) = type->u.contig.child->u.hvector.child->u.hvector.blocklength;
2965 intptr_t stride3 = type->u.contig.child->u.hvector.child->u.hvector.stride;
2966 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.contig.child->u.hvector.child->extent;
2967
2968 uintptr_t idx = 0;
2969 for (int i = 0; i < count; i++) {
2970 for (int j1 = 0; j1 < count1; j1++) {
2971 for (int j2 = 0; j2 < count2; j2++) {
2972 for (int k2 = 0; k2 < blocklength2; k2++) {
2973 for (int j3 = 0; j3 < count3; j3++) {
2974 for (int k3 = 0; k3 < 1; k3++) {
2975 *((int8_t *) (void *) (dbuf + idx)) = *((const int8_t *) (const void *) (sbuf + i * extent + j1 * stride1 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t)));
2976 idx += sizeof(int8_t);
2977 }
2978 }
2979 }
2980 }
2981 }
2982 }
2983
2984 return rc;
2985 }
2986
yaksuri_seqi_unpack_contig_hvector_hvector_blklen_1_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)2987 int yaksuri_seqi_unpack_contig_hvector_hvector_blklen_1_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
2988 {
2989 int rc = YAKSA_SUCCESS;
2990 const char *restrict sbuf = (const char *) inbuf;
2991 char *restrict dbuf = (char *) outbuf;
2992 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
2993
2994 int count1 = type->u.contig.count;
2995 intptr_t stride1 = type->u.contig.child->extent;
2996 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
2997
2998 int count2 = type->u.contig.child->u.hvector.count;
2999 int blocklength2 ATTRIBUTE((unused)) = type->u.contig.child->u.hvector.blocklength;
3000 intptr_t stride2 = type->u.contig.child->u.hvector.stride;
3001 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.contig.child->extent;
3002
3003 int count3 = type->u.contig.child->u.hvector.child->u.hvector.count;
3004 int blocklength3 ATTRIBUTE((unused)) = type->u.contig.child->u.hvector.child->u.hvector.blocklength;
3005 intptr_t stride3 = type->u.contig.child->u.hvector.child->u.hvector.stride;
3006 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.contig.child->u.hvector.child->extent;
3007
3008 uintptr_t idx = 0;
3009 for (int i = 0; i < count; i++) {
3010 for (int j1 = 0; j1 < count1; j1++) {
3011 for (int j2 = 0; j2 < count2; j2++) {
3012 for (int k2 = 0; k2 < blocklength2; k2++) {
3013 for (int j3 = 0; j3 < count3; j3++) {
3014 for (int k3 = 0; k3 < 1; k3++) {
3015 *((int8_t *) (void *) (dbuf + i * extent + j1 * stride1 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t))) = *((const int8_t *) (const void *) (sbuf + idx));
3016 idx += sizeof(int8_t);
3017 }
3018 }
3019 }
3020 }
3021 }
3022 }
3023
3024 return rc;
3025 }
3026
yaksuri_seqi_pack_contig_hvector_hvector_blklen_2_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)3027 int yaksuri_seqi_pack_contig_hvector_hvector_blklen_2_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
3028 {
3029 int rc = YAKSA_SUCCESS;
3030 const char *restrict sbuf = (const char *) inbuf;
3031 char *restrict dbuf = (char *) outbuf;
3032 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
3033
3034 int count1 = type->u.contig.count;
3035 intptr_t stride1 = type->u.contig.child->extent;
3036 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
3037
3038 int count2 = type->u.contig.child->u.hvector.count;
3039 int blocklength2 ATTRIBUTE((unused)) = type->u.contig.child->u.hvector.blocklength;
3040 intptr_t stride2 = type->u.contig.child->u.hvector.stride;
3041 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.contig.child->extent;
3042
3043 int count3 = type->u.contig.child->u.hvector.child->u.hvector.count;
3044 int blocklength3 ATTRIBUTE((unused)) = type->u.contig.child->u.hvector.child->u.hvector.blocklength;
3045 intptr_t stride3 = type->u.contig.child->u.hvector.child->u.hvector.stride;
3046 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.contig.child->u.hvector.child->extent;
3047
3048 uintptr_t idx = 0;
3049 for (int i = 0; i < count; i++) {
3050 for (int j1 = 0; j1 < count1; j1++) {
3051 for (int j2 = 0; j2 < count2; j2++) {
3052 for (int k2 = 0; k2 < blocklength2; k2++) {
3053 for (int j3 = 0; j3 < count3; j3++) {
3054 for (int k3 = 0; k3 < 2; k3++) {
3055 *((int8_t *) (void *) (dbuf + idx)) = *((const int8_t *) (const void *) (sbuf + i * extent + j1 * stride1 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t)));
3056 idx += sizeof(int8_t);
3057 }
3058 }
3059 }
3060 }
3061 }
3062 }
3063
3064 return rc;
3065 }
3066
yaksuri_seqi_unpack_contig_hvector_hvector_blklen_2_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)3067 int yaksuri_seqi_unpack_contig_hvector_hvector_blklen_2_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
3068 {
3069 int rc = YAKSA_SUCCESS;
3070 const char *restrict sbuf = (const char *) inbuf;
3071 char *restrict dbuf = (char *) outbuf;
3072 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
3073
3074 int count1 = type->u.contig.count;
3075 intptr_t stride1 = type->u.contig.child->extent;
3076 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
3077
3078 int count2 = type->u.contig.child->u.hvector.count;
3079 int blocklength2 ATTRIBUTE((unused)) = type->u.contig.child->u.hvector.blocklength;
3080 intptr_t stride2 = type->u.contig.child->u.hvector.stride;
3081 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.contig.child->extent;
3082
3083 int count3 = type->u.contig.child->u.hvector.child->u.hvector.count;
3084 int blocklength3 ATTRIBUTE((unused)) = type->u.contig.child->u.hvector.child->u.hvector.blocklength;
3085 intptr_t stride3 = type->u.contig.child->u.hvector.child->u.hvector.stride;
3086 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.contig.child->u.hvector.child->extent;
3087
3088 uintptr_t idx = 0;
3089 for (int i = 0; i < count; i++) {
3090 for (int j1 = 0; j1 < count1; j1++) {
3091 for (int j2 = 0; j2 < count2; j2++) {
3092 for (int k2 = 0; k2 < blocklength2; k2++) {
3093 for (int j3 = 0; j3 < count3; j3++) {
3094 for (int k3 = 0; k3 < 2; k3++) {
3095 *((int8_t *) (void *) (dbuf + i * extent + j1 * stride1 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t))) = *((const int8_t *) (const void *) (sbuf + idx));
3096 idx += sizeof(int8_t);
3097 }
3098 }
3099 }
3100 }
3101 }
3102 }
3103
3104 return rc;
3105 }
3106
yaksuri_seqi_pack_contig_hvector_hvector_blklen_3_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)3107 int yaksuri_seqi_pack_contig_hvector_hvector_blklen_3_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
3108 {
3109 int rc = YAKSA_SUCCESS;
3110 const char *restrict sbuf = (const char *) inbuf;
3111 char *restrict dbuf = (char *) outbuf;
3112 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
3113
3114 int count1 = type->u.contig.count;
3115 intptr_t stride1 = type->u.contig.child->extent;
3116 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
3117
3118 int count2 = type->u.contig.child->u.hvector.count;
3119 int blocklength2 ATTRIBUTE((unused)) = type->u.contig.child->u.hvector.blocklength;
3120 intptr_t stride2 = type->u.contig.child->u.hvector.stride;
3121 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.contig.child->extent;
3122
3123 int count3 = type->u.contig.child->u.hvector.child->u.hvector.count;
3124 int blocklength3 ATTRIBUTE((unused)) = type->u.contig.child->u.hvector.child->u.hvector.blocklength;
3125 intptr_t stride3 = type->u.contig.child->u.hvector.child->u.hvector.stride;
3126 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.contig.child->u.hvector.child->extent;
3127
3128 uintptr_t idx = 0;
3129 for (int i = 0; i < count; i++) {
3130 for (int j1 = 0; j1 < count1; j1++) {
3131 for (int j2 = 0; j2 < count2; j2++) {
3132 for (int k2 = 0; k2 < blocklength2; k2++) {
3133 for (int j3 = 0; j3 < count3; j3++) {
3134 for (int k3 = 0; k3 < 3; k3++) {
3135 *((int8_t *) (void *) (dbuf + idx)) = *((const int8_t *) (const void *) (sbuf + i * extent + j1 * stride1 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t)));
3136 idx += sizeof(int8_t);
3137 }
3138 }
3139 }
3140 }
3141 }
3142 }
3143
3144 return rc;
3145 }
3146
yaksuri_seqi_unpack_contig_hvector_hvector_blklen_3_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)3147 int yaksuri_seqi_unpack_contig_hvector_hvector_blklen_3_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
3148 {
3149 int rc = YAKSA_SUCCESS;
3150 const char *restrict sbuf = (const char *) inbuf;
3151 char *restrict dbuf = (char *) outbuf;
3152 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
3153
3154 int count1 = type->u.contig.count;
3155 intptr_t stride1 = type->u.contig.child->extent;
3156 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
3157
3158 int count2 = type->u.contig.child->u.hvector.count;
3159 int blocklength2 ATTRIBUTE((unused)) = type->u.contig.child->u.hvector.blocklength;
3160 intptr_t stride2 = type->u.contig.child->u.hvector.stride;
3161 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.contig.child->extent;
3162
3163 int count3 = type->u.contig.child->u.hvector.child->u.hvector.count;
3164 int blocklength3 ATTRIBUTE((unused)) = type->u.contig.child->u.hvector.child->u.hvector.blocklength;
3165 intptr_t stride3 = type->u.contig.child->u.hvector.child->u.hvector.stride;
3166 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.contig.child->u.hvector.child->extent;
3167
3168 uintptr_t idx = 0;
3169 for (int i = 0; i < count; i++) {
3170 for (int j1 = 0; j1 < count1; j1++) {
3171 for (int j2 = 0; j2 < count2; j2++) {
3172 for (int k2 = 0; k2 < blocklength2; k2++) {
3173 for (int j3 = 0; j3 < count3; j3++) {
3174 for (int k3 = 0; k3 < 3; k3++) {
3175 *((int8_t *) (void *) (dbuf + i * extent + j1 * stride1 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t))) = *((const int8_t *) (const void *) (sbuf + idx));
3176 idx += sizeof(int8_t);
3177 }
3178 }
3179 }
3180 }
3181 }
3182 }
3183
3184 return rc;
3185 }
3186
yaksuri_seqi_pack_contig_hvector_hvector_blklen_4_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)3187 int yaksuri_seqi_pack_contig_hvector_hvector_blklen_4_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
3188 {
3189 int rc = YAKSA_SUCCESS;
3190 const char *restrict sbuf = (const char *) inbuf;
3191 char *restrict dbuf = (char *) outbuf;
3192 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
3193
3194 int count1 = type->u.contig.count;
3195 intptr_t stride1 = type->u.contig.child->extent;
3196 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
3197
3198 int count2 = type->u.contig.child->u.hvector.count;
3199 int blocklength2 ATTRIBUTE((unused)) = type->u.contig.child->u.hvector.blocklength;
3200 intptr_t stride2 = type->u.contig.child->u.hvector.stride;
3201 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.contig.child->extent;
3202
3203 int count3 = type->u.contig.child->u.hvector.child->u.hvector.count;
3204 int blocklength3 ATTRIBUTE((unused)) = type->u.contig.child->u.hvector.child->u.hvector.blocklength;
3205 intptr_t stride3 = type->u.contig.child->u.hvector.child->u.hvector.stride;
3206 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.contig.child->u.hvector.child->extent;
3207
3208 uintptr_t idx = 0;
3209 for (int i = 0; i < count; i++) {
3210 for (int j1 = 0; j1 < count1; j1++) {
3211 for (int j2 = 0; j2 < count2; j2++) {
3212 for (int k2 = 0; k2 < blocklength2; k2++) {
3213 for (int j3 = 0; j3 < count3; j3++) {
3214 for (int k3 = 0; k3 < 4; k3++) {
3215 *((int8_t *) (void *) (dbuf + idx)) = *((const int8_t *) (const void *) (sbuf + i * extent + j1 * stride1 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t)));
3216 idx += sizeof(int8_t);
3217 }
3218 }
3219 }
3220 }
3221 }
3222 }
3223
3224 return rc;
3225 }
3226
yaksuri_seqi_unpack_contig_hvector_hvector_blklen_4_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)3227 int yaksuri_seqi_unpack_contig_hvector_hvector_blklen_4_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
3228 {
3229 int rc = YAKSA_SUCCESS;
3230 const char *restrict sbuf = (const char *) inbuf;
3231 char *restrict dbuf = (char *) outbuf;
3232 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
3233
3234 int count1 = type->u.contig.count;
3235 intptr_t stride1 = type->u.contig.child->extent;
3236 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
3237
3238 int count2 = type->u.contig.child->u.hvector.count;
3239 int blocklength2 ATTRIBUTE((unused)) = type->u.contig.child->u.hvector.blocklength;
3240 intptr_t stride2 = type->u.contig.child->u.hvector.stride;
3241 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.contig.child->extent;
3242
3243 int count3 = type->u.contig.child->u.hvector.child->u.hvector.count;
3244 int blocklength3 ATTRIBUTE((unused)) = type->u.contig.child->u.hvector.child->u.hvector.blocklength;
3245 intptr_t stride3 = type->u.contig.child->u.hvector.child->u.hvector.stride;
3246 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.contig.child->u.hvector.child->extent;
3247
3248 uintptr_t idx = 0;
3249 for (int i = 0; i < count; i++) {
3250 for (int j1 = 0; j1 < count1; j1++) {
3251 for (int j2 = 0; j2 < count2; j2++) {
3252 for (int k2 = 0; k2 < blocklength2; k2++) {
3253 for (int j3 = 0; j3 < count3; j3++) {
3254 for (int k3 = 0; k3 < 4; k3++) {
3255 *((int8_t *) (void *) (dbuf + i * extent + j1 * stride1 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t))) = *((const int8_t *) (const void *) (sbuf + idx));
3256 idx += sizeof(int8_t);
3257 }
3258 }
3259 }
3260 }
3261 }
3262 }
3263
3264 return rc;
3265 }
3266
yaksuri_seqi_pack_contig_hvector_hvector_blklen_5_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)3267 int yaksuri_seqi_pack_contig_hvector_hvector_blklen_5_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
3268 {
3269 int rc = YAKSA_SUCCESS;
3270 const char *restrict sbuf = (const char *) inbuf;
3271 char *restrict dbuf = (char *) outbuf;
3272 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
3273
3274 int count1 = type->u.contig.count;
3275 intptr_t stride1 = type->u.contig.child->extent;
3276 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
3277
3278 int count2 = type->u.contig.child->u.hvector.count;
3279 int blocklength2 ATTRIBUTE((unused)) = type->u.contig.child->u.hvector.blocklength;
3280 intptr_t stride2 = type->u.contig.child->u.hvector.stride;
3281 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.contig.child->extent;
3282
3283 int count3 = type->u.contig.child->u.hvector.child->u.hvector.count;
3284 int blocklength3 ATTRIBUTE((unused)) = type->u.contig.child->u.hvector.child->u.hvector.blocklength;
3285 intptr_t stride3 = type->u.contig.child->u.hvector.child->u.hvector.stride;
3286 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.contig.child->u.hvector.child->extent;
3287
3288 uintptr_t idx = 0;
3289 for (int i = 0; i < count; i++) {
3290 for (int j1 = 0; j1 < count1; j1++) {
3291 for (int j2 = 0; j2 < count2; j2++) {
3292 for (int k2 = 0; k2 < blocklength2; k2++) {
3293 for (int j3 = 0; j3 < count3; j3++) {
3294 for (int k3 = 0; k3 < 5; k3++) {
3295 *((int8_t *) (void *) (dbuf + idx)) = *((const int8_t *) (const void *) (sbuf + i * extent + j1 * stride1 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t)));
3296 idx += sizeof(int8_t);
3297 }
3298 }
3299 }
3300 }
3301 }
3302 }
3303
3304 return rc;
3305 }
3306
yaksuri_seqi_unpack_contig_hvector_hvector_blklen_5_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)3307 int yaksuri_seqi_unpack_contig_hvector_hvector_blklen_5_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
3308 {
3309 int rc = YAKSA_SUCCESS;
3310 const char *restrict sbuf = (const char *) inbuf;
3311 char *restrict dbuf = (char *) outbuf;
3312 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
3313
3314 int count1 = type->u.contig.count;
3315 intptr_t stride1 = type->u.contig.child->extent;
3316 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
3317
3318 int count2 = type->u.contig.child->u.hvector.count;
3319 int blocklength2 ATTRIBUTE((unused)) = type->u.contig.child->u.hvector.blocklength;
3320 intptr_t stride2 = type->u.contig.child->u.hvector.stride;
3321 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.contig.child->extent;
3322
3323 int count3 = type->u.contig.child->u.hvector.child->u.hvector.count;
3324 int blocklength3 ATTRIBUTE((unused)) = type->u.contig.child->u.hvector.child->u.hvector.blocklength;
3325 intptr_t stride3 = type->u.contig.child->u.hvector.child->u.hvector.stride;
3326 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.contig.child->u.hvector.child->extent;
3327
3328 uintptr_t idx = 0;
3329 for (int i = 0; i < count; i++) {
3330 for (int j1 = 0; j1 < count1; j1++) {
3331 for (int j2 = 0; j2 < count2; j2++) {
3332 for (int k2 = 0; k2 < blocklength2; k2++) {
3333 for (int j3 = 0; j3 < count3; j3++) {
3334 for (int k3 = 0; k3 < 5; k3++) {
3335 *((int8_t *) (void *) (dbuf + i * extent + j1 * stride1 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t))) = *((const int8_t *) (const void *) (sbuf + idx));
3336 idx += sizeof(int8_t);
3337 }
3338 }
3339 }
3340 }
3341 }
3342 }
3343
3344 return rc;
3345 }
3346
yaksuri_seqi_pack_contig_hvector_hvector_blklen_6_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)3347 int yaksuri_seqi_pack_contig_hvector_hvector_blklen_6_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
3348 {
3349 int rc = YAKSA_SUCCESS;
3350 const char *restrict sbuf = (const char *) inbuf;
3351 char *restrict dbuf = (char *) outbuf;
3352 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
3353
3354 int count1 = type->u.contig.count;
3355 intptr_t stride1 = type->u.contig.child->extent;
3356 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
3357
3358 int count2 = type->u.contig.child->u.hvector.count;
3359 int blocklength2 ATTRIBUTE((unused)) = type->u.contig.child->u.hvector.blocklength;
3360 intptr_t stride2 = type->u.contig.child->u.hvector.stride;
3361 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.contig.child->extent;
3362
3363 int count3 = type->u.contig.child->u.hvector.child->u.hvector.count;
3364 int blocklength3 ATTRIBUTE((unused)) = type->u.contig.child->u.hvector.child->u.hvector.blocklength;
3365 intptr_t stride3 = type->u.contig.child->u.hvector.child->u.hvector.stride;
3366 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.contig.child->u.hvector.child->extent;
3367
3368 uintptr_t idx = 0;
3369 for (int i = 0; i < count; i++) {
3370 for (int j1 = 0; j1 < count1; j1++) {
3371 for (int j2 = 0; j2 < count2; j2++) {
3372 for (int k2 = 0; k2 < blocklength2; k2++) {
3373 for (int j3 = 0; j3 < count3; j3++) {
3374 for (int k3 = 0; k3 < 6; k3++) {
3375 *((int8_t *) (void *) (dbuf + idx)) = *((const int8_t *) (const void *) (sbuf + i * extent + j1 * stride1 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t)));
3376 idx += sizeof(int8_t);
3377 }
3378 }
3379 }
3380 }
3381 }
3382 }
3383
3384 return rc;
3385 }
3386
yaksuri_seqi_unpack_contig_hvector_hvector_blklen_6_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)3387 int yaksuri_seqi_unpack_contig_hvector_hvector_blklen_6_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
3388 {
3389 int rc = YAKSA_SUCCESS;
3390 const char *restrict sbuf = (const char *) inbuf;
3391 char *restrict dbuf = (char *) outbuf;
3392 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
3393
3394 int count1 = type->u.contig.count;
3395 intptr_t stride1 = type->u.contig.child->extent;
3396 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
3397
3398 int count2 = type->u.contig.child->u.hvector.count;
3399 int blocklength2 ATTRIBUTE((unused)) = type->u.contig.child->u.hvector.blocklength;
3400 intptr_t stride2 = type->u.contig.child->u.hvector.stride;
3401 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.contig.child->extent;
3402
3403 int count3 = type->u.contig.child->u.hvector.child->u.hvector.count;
3404 int blocklength3 ATTRIBUTE((unused)) = type->u.contig.child->u.hvector.child->u.hvector.blocklength;
3405 intptr_t stride3 = type->u.contig.child->u.hvector.child->u.hvector.stride;
3406 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.contig.child->u.hvector.child->extent;
3407
3408 uintptr_t idx = 0;
3409 for (int i = 0; i < count; i++) {
3410 for (int j1 = 0; j1 < count1; j1++) {
3411 for (int j2 = 0; j2 < count2; j2++) {
3412 for (int k2 = 0; k2 < blocklength2; k2++) {
3413 for (int j3 = 0; j3 < count3; j3++) {
3414 for (int k3 = 0; k3 < 6; k3++) {
3415 *((int8_t *) (void *) (dbuf + i * extent + j1 * stride1 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t))) = *((const int8_t *) (const void *) (sbuf + idx));
3416 idx += sizeof(int8_t);
3417 }
3418 }
3419 }
3420 }
3421 }
3422 }
3423
3424 return rc;
3425 }
3426
yaksuri_seqi_pack_contig_hvector_hvector_blklen_7_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)3427 int yaksuri_seqi_pack_contig_hvector_hvector_blklen_7_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
3428 {
3429 int rc = YAKSA_SUCCESS;
3430 const char *restrict sbuf = (const char *) inbuf;
3431 char *restrict dbuf = (char *) outbuf;
3432 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
3433
3434 int count1 = type->u.contig.count;
3435 intptr_t stride1 = type->u.contig.child->extent;
3436 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
3437
3438 int count2 = type->u.contig.child->u.hvector.count;
3439 int blocklength2 ATTRIBUTE((unused)) = type->u.contig.child->u.hvector.blocklength;
3440 intptr_t stride2 = type->u.contig.child->u.hvector.stride;
3441 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.contig.child->extent;
3442
3443 int count3 = type->u.contig.child->u.hvector.child->u.hvector.count;
3444 int blocklength3 ATTRIBUTE((unused)) = type->u.contig.child->u.hvector.child->u.hvector.blocklength;
3445 intptr_t stride3 = type->u.contig.child->u.hvector.child->u.hvector.stride;
3446 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.contig.child->u.hvector.child->extent;
3447
3448 uintptr_t idx = 0;
3449 for (int i = 0; i < count; i++) {
3450 for (int j1 = 0; j1 < count1; j1++) {
3451 for (int j2 = 0; j2 < count2; j2++) {
3452 for (int k2 = 0; k2 < blocklength2; k2++) {
3453 for (int j3 = 0; j3 < count3; j3++) {
3454 for (int k3 = 0; k3 < 7; k3++) {
3455 *((int8_t *) (void *) (dbuf + idx)) = *((const int8_t *) (const void *) (sbuf + i * extent + j1 * stride1 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t)));
3456 idx += sizeof(int8_t);
3457 }
3458 }
3459 }
3460 }
3461 }
3462 }
3463
3464 return rc;
3465 }
3466
yaksuri_seqi_unpack_contig_hvector_hvector_blklen_7_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)3467 int yaksuri_seqi_unpack_contig_hvector_hvector_blklen_7_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
3468 {
3469 int rc = YAKSA_SUCCESS;
3470 const char *restrict sbuf = (const char *) inbuf;
3471 char *restrict dbuf = (char *) outbuf;
3472 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
3473
3474 int count1 = type->u.contig.count;
3475 intptr_t stride1 = type->u.contig.child->extent;
3476 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
3477
3478 int count2 = type->u.contig.child->u.hvector.count;
3479 int blocklength2 ATTRIBUTE((unused)) = type->u.contig.child->u.hvector.blocklength;
3480 intptr_t stride2 = type->u.contig.child->u.hvector.stride;
3481 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.contig.child->extent;
3482
3483 int count3 = type->u.contig.child->u.hvector.child->u.hvector.count;
3484 int blocklength3 ATTRIBUTE((unused)) = type->u.contig.child->u.hvector.child->u.hvector.blocklength;
3485 intptr_t stride3 = type->u.contig.child->u.hvector.child->u.hvector.stride;
3486 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.contig.child->u.hvector.child->extent;
3487
3488 uintptr_t idx = 0;
3489 for (int i = 0; i < count; i++) {
3490 for (int j1 = 0; j1 < count1; j1++) {
3491 for (int j2 = 0; j2 < count2; j2++) {
3492 for (int k2 = 0; k2 < blocklength2; k2++) {
3493 for (int j3 = 0; j3 < count3; j3++) {
3494 for (int k3 = 0; k3 < 7; k3++) {
3495 *((int8_t *) (void *) (dbuf + i * extent + j1 * stride1 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t))) = *((const int8_t *) (const void *) (sbuf + idx));
3496 idx += sizeof(int8_t);
3497 }
3498 }
3499 }
3500 }
3501 }
3502 }
3503
3504 return rc;
3505 }
3506
yaksuri_seqi_pack_contig_hvector_hvector_blklen_8_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)3507 int yaksuri_seqi_pack_contig_hvector_hvector_blklen_8_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
3508 {
3509 int rc = YAKSA_SUCCESS;
3510 const char *restrict sbuf = (const char *) inbuf;
3511 char *restrict dbuf = (char *) outbuf;
3512 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
3513
3514 int count1 = type->u.contig.count;
3515 intptr_t stride1 = type->u.contig.child->extent;
3516 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
3517
3518 int count2 = type->u.contig.child->u.hvector.count;
3519 int blocklength2 ATTRIBUTE((unused)) = type->u.contig.child->u.hvector.blocklength;
3520 intptr_t stride2 = type->u.contig.child->u.hvector.stride;
3521 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.contig.child->extent;
3522
3523 int count3 = type->u.contig.child->u.hvector.child->u.hvector.count;
3524 int blocklength3 ATTRIBUTE((unused)) = type->u.contig.child->u.hvector.child->u.hvector.blocklength;
3525 intptr_t stride3 = type->u.contig.child->u.hvector.child->u.hvector.stride;
3526 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.contig.child->u.hvector.child->extent;
3527
3528 uintptr_t idx = 0;
3529 for (int i = 0; i < count; i++) {
3530 for (int j1 = 0; j1 < count1; j1++) {
3531 for (int j2 = 0; j2 < count2; j2++) {
3532 for (int k2 = 0; k2 < blocklength2; k2++) {
3533 for (int j3 = 0; j3 < count3; j3++) {
3534 for (int k3 = 0; k3 < 8; k3++) {
3535 *((int8_t *) (void *) (dbuf + idx)) = *((const int8_t *) (const void *) (sbuf + i * extent + j1 * stride1 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t)));
3536 idx += sizeof(int8_t);
3537 }
3538 }
3539 }
3540 }
3541 }
3542 }
3543
3544 return rc;
3545 }
3546
yaksuri_seqi_unpack_contig_hvector_hvector_blklen_8_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)3547 int yaksuri_seqi_unpack_contig_hvector_hvector_blklen_8_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
3548 {
3549 int rc = YAKSA_SUCCESS;
3550 const char *restrict sbuf = (const char *) inbuf;
3551 char *restrict dbuf = (char *) outbuf;
3552 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
3553
3554 int count1 = type->u.contig.count;
3555 intptr_t stride1 = type->u.contig.child->extent;
3556 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
3557
3558 int count2 = type->u.contig.child->u.hvector.count;
3559 int blocklength2 ATTRIBUTE((unused)) = type->u.contig.child->u.hvector.blocklength;
3560 intptr_t stride2 = type->u.contig.child->u.hvector.stride;
3561 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.contig.child->extent;
3562
3563 int count3 = type->u.contig.child->u.hvector.child->u.hvector.count;
3564 int blocklength3 ATTRIBUTE((unused)) = type->u.contig.child->u.hvector.child->u.hvector.blocklength;
3565 intptr_t stride3 = type->u.contig.child->u.hvector.child->u.hvector.stride;
3566 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.contig.child->u.hvector.child->extent;
3567
3568 uintptr_t idx = 0;
3569 for (int i = 0; i < count; i++) {
3570 for (int j1 = 0; j1 < count1; j1++) {
3571 for (int j2 = 0; j2 < count2; j2++) {
3572 for (int k2 = 0; k2 < blocklength2; k2++) {
3573 for (int j3 = 0; j3 < count3; j3++) {
3574 for (int k3 = 0; k3 < 8; k3++) {
3575 *((int8_t *) (void *) (dbuf + i * extent + j1 * stride1 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t))) = *((const int8_t *) (const void *) (sbuf + idx));
3576 idx += sizeof(int8_t);
3577 }
3578 }
3579 }
3580 }
3581 }
3582 }
3583
3584 return rc;
3585 }
3586
yaksuri_seqi_pack_contig_hvector_hvector_blklen_generic_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)3587 int yaksuri_seqi_pack_contig_hvector_hvector_blklen_generic_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
3588 {
3589 int rc = YAKSA_SUCCESS;
3590 const char *restrict sbuf = (const char *) inbuf;
3591 char *restrict dbuf = (char *) outbuf;
3592 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
3593
3594 int count1 = type->u.contig.count;
3595 intptr_t stride1 = type->u.contig.child->extent;
3596 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
3597
3598 int count2 = type->u.contig.child->u.hvector.count;
3599 int blocklength2 ATTRIBUTE((unused)) = type->u.contig.child->u.hvector.blocklength;
3600 intptr_t stride2 = type->u.contig.child->u.hvector.stride;
3601 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.contig.child->extent;
3602
3603 int count3 = type->u.contig.child->u.hvector.child->u.hvector.count;
3604 int blocklength3 ATTRIBUTE((unused)) = type->u.contig.child->u.hvector.child->u.hvector.blocklength;
3605 intptr_t stride3 = type->u.contig.child->u.hvector.child->u.hvector.stride;
3606 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.contig.child->u.hvector.child->extent;
3607
3608 uintptr_t idx = 0;
3609 for (int i = 0; i < count; i++) {
3610 for (int j1 = 0; j1 < count1; j1++) {
3611 for (int j2 = 0; j2 < count2; j2++) {
3612 for (int k2 = 0; k2 < blocklength2; k2++) {
3613 for (int j3 = 0; j3 < count3; j3++) {
3614 for (int k3 = 0; k3 < blocklength3; k3++) {
3615 *((int8_t *) (void *) (dbuf + idx)) = *((const int8_t *) (const void *) (sbuf + i * extent + j1 * stride1 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t)));
3616 idx += sizeof(int8_t);
3617 }
3618 }
3619 }
3620 }
3621 }
3622 }
3623
3624 return rc;
3625 }
3626
yaksuri_seqi_unpack_contig_hvector_hvector_blklen_generic_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)3627 int yaksuri_seqi_unpack_contig_hvector_hvector_blklen_generic_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
3628 {
3629 int rc = YAKSA_SUCCESS;
3630 const char *restrict sbuf = (const char *) inbuf;
3631 char *restrict dbuf = (char *) outbuf;
3632 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
3633
3634 int count1 = type->u.contig.count;
3635 intptr_t stride1 = type->u.contig.child->extent;
3636 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
3637
3638 int count2 = type->u.contig.child->u.hvector.count;
3639 int blocklength2 ATTRIBUTE((unused)) = type->u.contig.child->u.hvector.blocklength;
3640 intptr_t stride2 = type->u.contig.child->u.hvector.stride;
3641 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.contig.child->extent;
3642
3643 int count3 = type->u.contig.child->u.hvector.child->u.hvector.count;
3644 int blocklength3 ATTRIBUTE((unused)) = type->u.contig.child->u.hvector.child->u.hvector.blocklength;
3645 intptr_t stride3 = type->u.contig.child->u.hvector.child->u.hvector.stride;
3646 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.contig.child->u.hvector.child->extent;
3647
3648 uintptr_t idx = 0;
3649 for (int i = 0; i < count; i++) {
3650 for (int j1 = 0; j1 < count1; j1++) {
3651 for (int j2 = 0; j2 < count2; j2++) {
3652 for (int k2 = 0; k2 < blocklength2; k2++) {
3653 for (int j3 = 0; j3 < count3; j3++) {
3654 for (int k3 = 0; k3 < blocklength3; k3++) {
3655 *((int8_t *) (void *) (dbuf + i * extent + j1 * stride1 + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t))) = *((const int8_t *) (const void *) (sbuf + idx));
3656 idx += sizeof(int8_t);
3657 }
3658 }
3659 }
3660 }
3661 }
3662 }
3663
3664 return rc;
3665 }
3666
yaksuri_seqi_pack_resized_hvector_hvector_blklen_1_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)3667 int yaksuri_seqi_pack_resized_hvector_hvector_blklen_1_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
3668 {
3669 int rc = YAKSA_SUCCESS;
3670 const char *restrict sbuf = (const char *) inbuf;
3671 char *restrict dbuf = (char *) outbuf;
3672 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
3673
3674 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
3675
3676 int count2 = type->u.resized.child->u.hvector.count;
3677 int blocklength2 ATTRIBUTE((unused)) = type->u.resized.child->u.hvector.blocklength;
3678 intptr_t stride2 = type->u.resized.child->u.hvector.stride;
3679 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.resized.child->extent;
3680
3681 int count3 = type->u.resized.child->u.hvector.child->u.hvector.count;
3682 int blocklength3 ATTRIBUTE((unused)) = type->u.resized.child->u.hvector.child->u.hvector.blocklength;
3683 intptr_t stride3 = type->u.resized.child->u.hvector.child->u.hvector.stride;
3684 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.resized.child->u.hvector.child->extent;
3685
3686 uintptr_t idx = 0;
3687 for (int i = 0; i < count; i++) {
3688 for (int j2 = 0; j2 < count2; j2++) {
3689 for (int k2 = 0; k2 < blocklength2; k2++) {
3690 for (int j3 = 0; j3 < count3; j3++) {
3691 for (int k3 = 0; k3 < 1; k3++) {
3692 *((int8_t *) (void *) (dbuf + idx)) = *((const int8_t *) (const void *) (sbuf + i * extent + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t)));
3693 idx += sizeof(int8_t);
3694 }
3695 }
3696 }
3697 }
3698 }
3699
3700 return rc;
3701 }
3702
yaksuri_seqi_unpack_resized_hvector_hvector_blklen_1_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)3703 int yaksuri_seqi_unpack_resized_hvector_hvector_blklen_1_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
3704 {
3705 int rc = YAKSA_SUCCESS;
3706 const char *restrict sbuf = (const char *) inbuf;
3707 char *restrict dbuf = (char *) outbuf;
3708 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
3709
3710 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
3711
3712 int count2 = type->u.resized.child->u.hvector.count;
3713 int blocklength2 ATTRIBUTE((unused)) = type->u.resized.child->u.hvector.blocklength;
3714 intptr_t stride2 = type->u.resized.child->u.hvector.stride;
3715 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.resized.child->extent;
3716
3717 int count3 = type->u.resized.child->u.hvector.child->u.hvector.count;
3718 int blocklength3 ATTRIBUTE((unused)) = type->u.resized.child->u.hvector.child->u.hvector.blocklength;
3719 intptr_t stride3 = type->u.resized.child->u.hvector.child->u.hvector.stride;
3720 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.resized.child->u.hvector.child->extent;
3721
3722 uintptr_t idx = 0;
3723 for (int i = 0; i < count; i++) {
3724 for (int j2 = 0; j2 < count2; j2++) {
3725 for (int k2 = 0; k2 < blocklength2; k2++) {
3726 for (int j3 = 0; j3 < count3; j3++) {
3727 for (int k3 = 0; k3 < 1; k3++) {
3728 *((int8_t *) (void *) (dbuf + i * extent + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t))) = *((const int8_t *) (const void *) (sbuf + idx));
3729 idx += sizeof(int8_t);
3730 }
3731 }
3732 }
3733 }
3734 }
3735
3736 return rc;
3737 }
3738
yaksuri_seqi_pack_resized_hvector_hvector_blklen_2_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)3739 int yaksuri_seqi_pack_resized_hvector_hvector_blklen_2_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
3740 {
3741 int rc = YAKSA_SUCCESS;
3742 const char *restrict sbuf = (const char *) inbuf;
3743 char *restrict dbuf = (char *) outbuf;
3744 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
3745
3746 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
3747
3748 int count2 = type->u.resized.child->u.hvector.count;
3749 int blocklength2 ATTRIBUTE((unused)) = type->u.resized.child->u.hvector.blocklength;
3750 intptr_t stride2 = type->u.resized.child->u.hvector.stride;
3751 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.resized.child->extent;
3752
3753 int count3 = type->u.resized.child->u.hvector.child->u.hvector.count;
3754 int blocklength3 ATTRIBUTE((unused)) = type->u.resized.child->u.hvector.child->u.hvector.blocklength;
3755 intptr_t stride3 = type->u.resized.child->u.hvector.child->u.hvector.stride;
3756 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.resized.child->u.hvector.child->extent;
3757
3758 uintptr_t idx = 0;
3759 for (int i = 0; i < count; i++) {
3760 for (int j2 = 0; j2 < count2; j2++) {
3761 for (int k2 = 0; k2 < blocklength2; k2++) {
3762 for (int j3 = 0; j3 < count3; j3++) {
3763 for (int k3 = 0; k3 < 2; k3++) {
3764 *((int8_t *) (void *) (dbuf + idx)) = *((const int8_t *) (const void *) (sbuf + i * extent + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t)));
3765 idx += sizeof(int8_t);
3766 }
3767 }
3768 }
3769 }
3770 }
3771
3772 return rc;
3773 }
3774
yaksuri_seqi_unpack_resized_hvector_hvector_blklen_2_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)3775 int yaksuri_seqi_unpack_resized_hvector_hvector_blklen_2_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
3776 {
3777 int rc = YAKSA_SUCCESS;
3778 const char *restrict sbuf = (const char *) inbuf;
3779 char *restrict dbuf = (char *) outbuf;
3780 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
3781
3782 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
3783
3784 int count2 = type->u.resized.child->u.hvector.count;
3785 int blocklength2 ATTRIBUTE((unused)) = type->u.resized.child->u.hvector.blocklength;
3786 intptr_t stride2 = type->u.resized.child->u.hvector.stride;
3787 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.resized.child->extent;
3788
3789 int count3 = type->u.resized.child->u.hvector.child->u.hvector.count;
3790 int blocklength3 ATTRIBUTE((unused)) = type->u.resized.child->u.hvector.child->u.hvector.blocklength;
3791 intptr_t stride3 = type->u.resized.child->u.hvector.child->u.hvector.stride;
3792 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.resized.child->u.hvector.child->extent;
3793
3794 uintptr_t idx = 0;
3795 for (int i = 0; i < count; i++) {
3796 for (int j2 = 0; j2 < count2; j2++) {
3797 for (int k2 = 0; k2 < blocklength2; k2++) {
3798 for (int j3 = 0; j3 < count3; j3++) {
3799 for (int k3 = 0; k3 < 2; k3++) {
3800 *((int8_t *) (void *) (dbuf + i * extent + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t))) = *((const int8_t *) (const void *) (sbuf + idx));
3801 idx += sizeof(int8_t);
3802 }
3803 }
3804 }
3805 }
3806 }
3807
3808 return rc;
3809 }
3810
yaksuri_seqi_pack_resized_hvector_hvector_blklen_3_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)3811 int yaksuri_seqi_pack_resized_hvector_hvector_blklen_3_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
3812 {
3813 int rc = YAKSA_SUCCESS;
3814 const char *restrict sbuf = (const char *) inbuf;
3815 char *restrict dbuf = (char *) outbuf;
3816 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
3817
3818 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
3819
3820 int count2 = type->u.resized.child->u.hvector.count;
3821 int blocklength2 ATTRIBUTE((unused)) = type->u.resized.child->u.hvector.blocklength;
3822 intptr_t stride2 = type->u.resized.child->u.hvector.stride;
3823 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.resized.child->extent;
3824
3825 int count3 = type->u.resized.child->u.hvector.child->u.hvector.count;
3826 int blocklength3 ATTRIBUTE((unused)) = type->u.resized.child->u.hvector.child->u.hvector.blocklength;
3827 intptr_t stride3 = type->u.resized.child->u.hvector.child->u.hvector.stride;
3828 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.resized.child->u.hvector.child->extent;
3829
3830 uintptr_t idx = 0;
3831 for (int i = 0; i < count; i++) {
3832 for (int j2 = 0; j2 < count2; j2++) {
3833 for (int k2 = 0; k2 < blocklength2; k2++) {
3834 for (int j3 = 0; j3 < count3; j3++) {
3835 for (int k3 = 0; k3 < 3; k3++) {
3836 *((int8_t *) (void *) (dbuf + idx)) = *((const int8_t *) (const void *) (sbuf + i * extent + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t)));
3837 idx += sizeof(int8_t);
3838 }
3839 }
3840 }
3841 }
3842 }
3843
3844 return rc;
3845 }
3846
yaksuri_seqi_unpack_resized_hvector_hvector_blklen_3_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)3847 int yaksuri_seqi_unpack_resized_hvector_hvector_blklen_3_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
3848 {
3849 int rc = YAKSA_SUCCESS;
3850 const char *restrict sbuf = (const char *) inbuf;
3851 char *restrict dbuf = (char *) outbuf;
3852 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
3853
3854 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
3855
3856 int count2 = type->u.resized.child->u.hvector.count;
3857 int blocklength2 ATTRIBUTE((unused)) = type->u.resized.child->u.hvector.blocklength;
3858 intptr_t stride2 = type->u.resized.child->u.hvector.stride;
3859 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.resized.child->extent;
3860
3861 int count3 = type->u.resized.child->u.hvector.child->u.hvector.count;
3862 int blocklength3 ATTRIBUTE((unused)) = type->u.resized.child->u.hvector.child->u.hvector.blocklength;
3863 intptr_t stride3 = type->u.resized.child->u.hvector.child->u.hvector.stride;
3864 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.resized.child->u.hvector.child->extent;
3865
3866 uintptr_t idx = 0;
3867 for (int i = 0; i < count; i++) {
3868 for (int j2 = 0; j2 < count2; j2++) {
3869 for (int k2 = 0; k2 < blocklength2; k2++) {
3870 for (int j3 = 0; j3 < count3; j3++) {
3871 for (int k3 = 0; k3 < 3; k3++) {
3872 *((int8_t *) (void *) (dbuf + i * extent + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t))) = *((const int8_t *) (const void *) (sbuf + idx));
3873 idx += sizeof(int8_t);
3874 }
3875 }
3876 }
3877 }
3878 }
3879
3880 return rc;
3881 }
3882
yaksuri_seqi_pack_resized_hvector_hvector_blklen_4_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)3883 int yaksuri_seqi_pack_resized_hvector_hvector_blklen_4_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
3884 {
3885 int rc = YAKSA_SUCCESS;
3886 const char *restrict sbuf = (const char *) inbuf;
3887 char *restrict dbuf = (char *) outbuf;
3888 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
3889
3890 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
3891
3892 int count2 = type->u.resized.child->u.hvector.count;
3893 int blocklength2 ATTRIBUTE((unused)) = type->u.resized.child->u.hvector.blocklength;
3894 intptr_t stride2 = type->u.resized.child->u.hvector.stride;
3895 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.resized.child->extent;
3896
3897 int count3 = type->u.resized.child->u.hvector.child->u.hvector.count;
3898 int blocklength3 ATTRIBUTE((unused)) = type->u.resized.child->u.hvector.child->u.hvector.blocklength;
3899 intptr_t stride3 = type->u.resized.child->u.hvector.child->u.hvector.stride;
3900 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.resized.child->u.hvector.child->extent;
3901
3902 uintptr_t idx = 0;
3903 for (int i = 0; i < count; i++) {
3904 for (int j2 = 0; j2 < count2; j2++) {
3905 for (int k2 = 0; k2 < blocklength2; k2++) {
3906 for (int j3 = 0; j3 < count3; j3++) {
3907 for (int k3 = 0; k3 < 4; k3++) {
3908 *((int8_t *) (void *) (dbuf + idx)) = *((const int8_t *) (const void *) (sbuf + i * extent + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t)));
3909 idx += sizeof(int8_t);
3910 }
3911 }
3912 }
3913 }
3914 }
3915
3916 return rc;
3917 }
3918
yaksuri_seqi_unpack_resized_hvector_hvector_blklen_4_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)3919 int yaksuri_seqi_unpack_resized_hvector_hvector_blklen_4_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
3920 {
3921 int rc = YAKSA_SUCCESS;
3922 const char *restrict sbuf = (const char *) inbuf;
3923 char *restrict dbuf = (char *) outbuf;
3924 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
3925
3926 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
3927
3928 int count2 = type->u.resized.child->u.hvector.count;
3929 int blocklength2 ATTRIBUTE((unused)) = type->u.resized.child->u.hvector.blocklength;
3930 intptr_t stride2 = type->u.resized.child->u.hvector.stride;
3931 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.resized.child->extent;
3932
3933 int count3 = type->u.resized.child->u.hvector.child->u.hvector.count;
3934 int blocklength3 ATTRIBUTE((unused)) = type->u.resized.child->u.hvector.child->u.hvector.blocklength;
3935 intptr_t stride3 = type->u.resized.child->u.hvector.child->u.hvector.stride;
3936 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.resized.child->u.hvector.child->extent;
3937
3938 uintptr_t idx = 0;
3939 for (int i = 0; i < count; i++) {
3940 for (int j2 = 0; j2 < count2; j2++) {
3941 for (int k2 = 0; k2 < blocklength2; k2++) {
3942 for (int j3 = 0; j3 < count3; j3++) {
3943 for (int k3 = 0; k3 < 4; k3++) {
3944 *((int8_t *) (void *) (dbuf + i * extent + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t))) = *((const int8_t *) (const void *) (sbuf + idx));
3945 idx += sizeof(int8_t);
3946 }
3947 }
3948 }
3949 }
3950 }
3951
3952 return rc;
3953 }
3954
yaksuri_seqi_pack_resized_hvector_hvector_blklen_5_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)3955 int yaksuri_seqi_pack_resized_hvector_hvector_blklen_5_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
3956 {
3957 int rc = YAKSA_SUCCESS;
3958 const char *restrict sbuf = (const char *) inbuf;
3959 char *restrict dbuf = (char *) outbuf;
3960 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
3961
3962 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
3963
3964 int count2 = type->u.resized.child->u.hvector.count;
3965 int blocklength2 ATTRIBUTE((unused)) = type->u.resized.child->u.hvector.blocklength;
3966 intptr_t stride2 = type->u.resized.child->u.hvector.stride;
3967 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.resized.child->extent;
3968
3969 int count3 = type->u.resized.child->u.hvector.child->u.hvector.count;
3970 int blocklength3 ATTRIBUTE((unused)) = type->u.resized.child->u.hvector.child->u.hvector.blocklength;
3971 intptr_t stride3 = type->u.resized.child->u.hvector.child->u.hvector.stride;
3972 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.resized.child->u.hvector.child->extent;
3973
3974 uintptr_t idx = 0;
3975 for (int i = 0; i < count; i++) {
3976 for (int j2 = 0; j2 < count2; j2++) {
3977 for (int k2 = 0; k2 < blocklength2; k2++) {
3978 for (int j3 = 0; j3 < count3; j3++) {
3979 for (int k3 = 0; k3 < 5; k3++) {
3980 *((int8_t *) (void *) (dbuf + idx)) = *((const int8_t *) (const void *) (sbuf + i * extent + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t)));
3981 idx += sizeof(int8_t);
3982 }
3983 }
3984 }
3985 }
3986 }
3987
3988 return rc;
3989 }
3990
yaksuri_seqi_unpack_resized_hvector_hvector_blklen_5_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)3991 int yaksuri_seqi_unpack_resized_hvector_hvector_blklen_5_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
3992 {
3993 int rc = YAKSA_SUCCESS;
3994 const char *restrict sbuf = (const char *) inbuf;
3995 char *restrict dbuf = (char *) outbuf;
3996 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
3997
3998 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
3999
4000 int count2 = type->u.resized.child->u.hvector.count;
4001 int blocklength2 ATTRIBUTE((unused)) = type->u.resized.child->u.hvector.blocklength;
4002 intptr_t stride2 = type->u.resized.child->u.hvector.stride;
4003 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.resized.child->extent;
4004
4005 int count3 = type->u.resized.child->u.hvector.child->u.hvector.count;
4006 int blocklength3 ATTRIBUTE((unused)) = type->u.resized.child->u.hvector.child->u.hvector.blocklength;
4007 intptr_t stride3 = type->u.resized.child->u.hvector.child->u.hvector.stride;
4008 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.resized.child->u.hvector.child->extent;
4009
4010 uintptr_t idx = 0;
4011 for (int i = 0; i < count; i++) {
4012 for (int j2 = 0; j2 < count2; j2++) {
4013 for (int k2 = 0; k2 < blocklength2; k2++) {
4014 for (int j3 = 0; j3 < count3; j3++) {
4015 for (int k3 = 0; k3 < 5; k3++) {
4016 *((int8_t *) (void *) (dbuf + i * extent + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t))) = *((const int8_t *) (const void *) (sbuf + idx));
4017 idx += sizeof(int8_t);
4018 }
4019 }
4020 }
4021 }
4022 }
4023
4024 return rc;
4025 }
4026
yaksuri_seqi_pack_resized_hvector_hvector_blklen_6_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)4027 int yaksuri_seqi_pack_resized_hvector_hvector_blklen_6_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
4028 {
4029 int rc = YAKSA_SUCCESS;
4030 const char *restrict sbuf = (const char *) inbuf;
4031 char *restrict dbuf = (char *) outbuf;
4032 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
4033
4034 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
4035
4036 int count2 = type->u.resized.child->u.hvector.count;
4037 int blocklength2 ATTRIBUTE((unused)) = type->u.resized.child->u.hvector.blocklength;
4038 intptr_t stride2 = type->u.resized.child->u.hvector.stride;
4039 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.resized.child->extent;
4040
4041 int count3 = type->u.resized.child->u.hvector.child->u.hvector.count;
4042 int blocklength3 ATTRIBUTE((unused)) = type->u.resized.child->u.hvector.child->u.hvector.blocklength;
4043 intptr_t stride3 = type->u.resized.child->u.hvector.child->u.hvector.stride;
4044 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.resized.child->u.hvector.child->extent;
4045
4046 uintptr_t idx = 0;
4047 for (int i = 0; i < count; i++) {
4048 for (int j2 = 0; j2 < count2; j2++) {
4049 for (int k2 = 0; k2 < blocklength2; k2++) {
4050 for (int j3 = 0; j3 < count3; j3++) {
4051 for (int k3 = 0; k3 < 6; k3++) {
4052 *((int8_t *) (void *) (dbuf + idx)) = *((const int8_t *) (const void *) (sbuf + i * extent + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t)));
4053 idx += sizeof(int8_t);
4054 }
4055 }
4056 }
4057 }
4058 }
4059
4060 return rc;
4061 }
4062
yaksuri_seqi_unpack_resized_hvector_hvector_blklen_6_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)4063 int yaksuri_seqi_unpack_resized_hvector_hvector_blklen_6_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
4064 {
4065 int rc = YAKSA_SUCCESS;
4066 const char *restrict sbuf = (const char *) inbuf;
4067 char *restrict dbuf = (char *) outbuf;
4068 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
4069
4070 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
4071
4072 int count2 = type->u.resized.child->u.hvector.count;
4073 int blocklength2 ATTRIBUTE((unused)) = type->u.resized.child->u.hvector.blocklength;
4074 intptr_t stride2 = type->u.resized.child->u.hvector.stride;
4075 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.resized.child->extent;
4076
4077 int count3 = type->u.resized.child->u.hvector.child->u.hvector.count;
4078 int blocklength3 ATTRIBUTE((unused)) = type->u.resized.child->u.hvector.child->u.hvector.blocklength;
4079 intptr_t stride3 = type->u.resized.child->u.hvector.child->u.hvector.stride;
4080 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.resized.child->u.hvector.child->extent;
4081
4082 uintptr_t idx = 0;
4083 for (int i = 0; i < count; i++) {
4084 for (int j2 = 0; j2 < count2; j2++) {
4085 for (int k2 = 0; k2 < blocklength2; k2++) {
4086 for (int j3 = 0; j3 < count3; j3++) {
4087 for (int k3 = 0; k3 < 6; k3++) {
4088 *((int8_t *) (void *) (dbuf + i * extent + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t))) = *((const int8_t *) (const void *) (sbuf + idx));
4089 idx += sizeof(int8_t);
4090 }
4091 }
4092 }
4093 }
4094 }
4095
4096 return rc;
4097 }
4098
yaksuri_seqi_pack_resized_hvector_hvector_blklen_7_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)4099 int yaksuri_seqi_pack_resized_hvector_hvector_blklen_7_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
4100 {
4101 int rc = YAKSA_SUCCESS;
4102 const char *restrict sbuf = (const char *) inbuf;
4103 char *restrict dbuf = (char *) outbuf;
4104 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
4105
4106 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
4107
4108 int count2 = type->u.resized.child->u.hvector.count;
4109 int blocklength2 ATTRIBUTE((unused)) = type->u.resized.child->u.hvector.blocklength;
4110 intptr_t stride2 = type->u.resized.child->u.hvector.stride;
4111 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.resized.child->extent;
4112
4113 int count3 = type->u.resized.child->u.hvector.child->u.hvector.count;
4114 int blocklength3 ATTRIBUTE((unused)) = type->u.resized.child->u.hvector.child->u.hvector.blocklength;
4115 intptr_t stride3 = type->u.resized.child->u.hvector.child->u.hvector.stride;
4116 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.resized.child->u.hvector.child->extent;
4117
4118 uintptr_t idx = 0;
4119 for (int i = 0; i < count; i++) {
4120 for (int j2 = 0; j2 < count2; j2++) {
4121 for (int k2 = 0; k2 < blocklength2; k2++) {
4122 for (int j3 = 0; j3 < count3; j3++) {
4123 for (int k3 = 0; k3 < 7; k3++) {
4124 *((int8_t *) (void *) (dbuf + idx)) = *((const int8_t *) (const void *) (sbuf + i * extent + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t)));
4125 idx += sizeof(int8_t);
4126 }
4127 }
4128 }
4129 }
4130 }
4131
4132 return rc;
4133 }
4134
yaksuri_seqi_unpack_resized_hvector_hvector_blklen_7_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)4135 int yaksuri_seqi_unpack_resized_hvector_hvector_blklen_7_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
4136 {
4137 int rc = YAKSA_SUCCESS;
4138 const char *restrict sbuf = (const char *) inbuf;
4139 char *restrict dbuf = (char *) outbuf;
4140 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
4141
4142 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
4143
4144 int count2 = type->u.resized.child->u.hvector.count;
4145 int blocklength2 ATTRIBUTE((unused)) = type->u.resized.child->u.hvector.blocklength;
4146 intptr_t stride2 = type->u.resized.child->u.hvector.stride;
4147 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.resized.child->extent;
4148
4149 int count3 = type->u.resized.child->u.hvector.child->u.hvector.count;
4150 int blocklength3 ATTRIBUTE((unused)) = type->u.resized.child->u.hvector.child->u.hvector.blocklength;
4151 intptr_t stride3 = type->u.resized.child->u.hvector.child->u.hvector.stride;
4152 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.resized.child->u.hvector.child->extent;
4153
4154 uintptr_t idx = 0;
4155 for (int i = 0; i < count; i++) {
4156 for (int j2 = 0; j2 < count2; j2++) {
4157 for (int k2 = 0; k2 < blocklength2; k2++) {
4158 for (int j3 = 0; j3 < count3; j3++) {
4159 for (int k3 = 0; k3 < 7; k3++) {
4160 *((int8_t *) (void *) (dbuf + i * extent + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t))) = *((const int8_t *) (const void *) (sbuf + idx));
4161 idx += sizeof(int8_t);
4162 }
4163 }
4164 }
4165 }
4166 }
4167
4168 return rc;
4169 }
4170
yaksuri_seqi_pack_resized_hvector_hvector_blklen_8_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)4171 int yaksuri_seqi_pack_resized_hvector_hvector_blklen_8_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
4172 {
4173 int rc = YAKSA_SUCCESS;
4174 const char *restrict sbuf = (const char *) inbuf;
4175 char *restrict dbuf = (char *) outbuf;
4176 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
4177
4178 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
4179
4180 int count2 = type->u.resized.child->u.hvector.count;
4181 int blocklength2 ATTRIBUTE((unused)) = type->u.resized.child->u.hvector.blocklength;
4182 intptr_t stride2 = type->u.resized.child->u.hvector.stride;
4183 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.resized.child->extent;
4184
4185 int count3 = type->u.resized.child->u.hvector.child->u.hvector.count;
4186 int blocklength3 ATTRIBUTE((unused)) = type->u.resized.child->u.hvector.child->u.hvector.blocklength;
4187 intptr_t stride3 = type->u.resized.child->u.hvector.child->u.hvector.stride;
4188 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.resized.child->u.hvector.child->extent;
4189
4190 uintptr_t idx = 0;
4191 for (int i = 0; i < count; i++) {
4192 for (int j2 = 0; j2 < count2; j2++) {
4193 for (int k2 = 0; k2 < blocklength2; k2++) {
4194 for (int j3 = 0; j3 < count3; j3++) {
4195 for (int k3 = 0; k3 < 8; k3++) {
4196 *((int8_t *) (void *) (dbuf + idx)) = *((const int8_t *) (const void *) (sbuf + i * extent + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t)));
4197 idx += sizeof(int8_t);
4198 }
4199 }
4200 }
4201 }
4202 }
4203
4204 return rc;
4205 }
4206
yaksuri_seqi_unpack_resized_hvector_hvector_blklen_8_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)4207 int yaksuri_seqi_unpack_resized_hvector_hvector_blklen_8_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
4208 {
4209 int rc = YAKSA_SUCCESS;
4210 const char *restrict sbuf = (const char *) inbuf;
4211 char *restrict dbuf = (char *) outbuf;
4212 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
4213
4214 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
4215
4216 int count2 = type->u.resized.child->u.hvector.count;
4217 int blocklength2 ATTRIBUTE((unused)) = type->u.resized.child->u.hvector.blocklength;
4218 intptr_t stride2 = type->u.resized.child->u.hvector.stride;
4219 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.resized.child->extent;
4220
4221 int count3 = type->u.resized.child->u.hvector.child->u.hvector.count;
4222 int blocklength3 ATTRIBUTE((unused)) = type->u.resized.child->u.hvector.child->u.hvector.blocklength;
4223 intptr_t stride3 = type->u.resized.child->u.hvector.child->u.hvector.stride;
4224 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.resized.child->u.hvector.child->extent;
4225
4226 uintptr_t idx = 0;
4227 for (int i = 0; i < count; i++) {
4228 for (int j2 = 0; j2 < count2; j2++) {
4229 for (int k2 = 0; k2 < blocklength2; k2++) {
4230 for (int j3 = 0; j3 < count3; j3++) {
4231 for (int k3 = 0; k3 < 8; k3++) {
4232 *((int8_t *) (void *) (dbuf + i * extent + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t))) = *((const int8_t *) (const void *) (sbuf + idx));
4233 idx += sizeof(int8_t);
4234 }
4235 }
4236 }
4237 }
4238 }
4239
4240 return rc;
4241 }
4242
yaksuri_seqi_pack_resized_hvector_hvector_blklen_generic_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)4243 int yaksuri_seqi_pack_resized_hvector_hvector_blklen_generic_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
4244 {
4245 int rc = YAKSA_SUCCESS;
4246 const char *restrict sbuf = (const char *) inbuf;
4247 char *restrict dbuf = (char *) outbuf;
4248 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
4249
4250 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
4251
4252 int count2 = type->u.resized.child->u.hvector.count;
4253 int blocklength2 ATTRIBUTE((unused)) = type->u.resized.child->u.hvector.blocklength;
4254 intptr_t stride2 = type->u.resized.child->u.hvector.stride;
4255 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.resized.child->extent;
4256
4257 int count3 = type->u.resized.child->u.hvector.child->u.hvector.count;
4258 int blocklength3 ATTRIBUTE((unused)) = type->u.resized.child->u.hvector.child->u.hvector.blocklength;
4259 intptr_t stride3 = type->u.resized.child->u.hvector.child->u.hvector.stride;
4260 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.resized.child->u.hvector.child->extent;
4261
4262 uintptr_t idx = 0;
4263 for (int i = 0; i < count; i++) {
4264 for (int j2 = 0; j2 < count2; j2++) {
4265 for (int k2 = 0; k2 < blocklength2; k2++) {
4266 for (int j3 = 0; j3 < count3; j3++) {
4267 for (int k3 = 0; k3 < blocklength3; k3++) {
4268 *((int8_t *) (void *) (dbuf + idx)) = *((const int8_t *) (const void *) (sbuf + i * extent + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t)));
4269 idx += sizeof(int8_t);
4270 }
4271 }
4272 }
4273 }
4274 }
4275
4276 return rc;
4277 }
4278
yaksuri_seqi_unpack_resized_hvector_hvector_blklen_generic_int8_t(const void * inbuf,void * outbuf,uintptr_t count,yaksi_type_s * type)4279 int yaksuri_seqi_unpack_resized_hvector_hvector_blklen_generic_int8_t(const void *inbuf, void *outbuf, uintptr_t count, yaksi_type_s * type)
4280 {
4281 int rc = YAKSA_SUCCESS;
4282 const char *restrict sbuf = (const char *) inbuf;
4283 char *restrict dbuf = (char *) outbuf;
4284 uintptr_t extent ATTRIBUTE((unused)) = type->extent;
4285
4286 uintptr_t extent1 ATTRIBUTE((unused)) = type->extent;
4287
4288 int count2 = type->u.resized.child->u.hvector.count;
4289 int blocklength2 ATTRIBUTE((unused)) = type->u.resized.child->u.hvector.blocklength;
4290 intptr_t stride2 = type->u.resized.child->u.hvector.stride;
4291 uintptr_t extent2 ATTRIBUTE((unused)) = type->u.resized.child->extent;
4292
4293 int count3 = type->u.resized.child->u.hvector.child->u.hvector.count;
4294 int blocklength3 ATTRIBUTE((unused)) = type->u.resized.child->u.hvector.child->u.hvector.blocklength;
4295 intptr_t stride3 = type->u.resized.child->u.hvector.child->u.hvector.stride;
4296 uintptr_t extent3 ATTRIBUTE((unused)) = type->u.resized.child->u.hvector.child->extent;
4297
4298 uintptr_t idx = 0;
4299 for (int i = 0; i < count; i++) {
4300 for (int j2 = 0; j2 < count2; j2++) {
4301 for (int k2 = 0; k2 < blocklength2; k2++) {
4302 for (int j3 = 0; j3 < count3; j3++) {
4303 for (int k3 = 0; k3 < blocklength3; k3++) {
4304 *((int8_t *) (void *) (dbuf + i * extent + j2 * stride2 + k2 * extent3 + j3 * stride3 + k3 * sizeof(int8_t))) = *((const int8_t *) (const void *) (sbuf + idx));
4305 idx += sizeof(int8_t);
4306 }
4307 }
4308 }
4309 }
4310 }
4311
4312 return rc;
4313 }
4314
4315