1 /* SPDX-License-Identifier: MIT
2 *
3 * Permission is hereby granted, free of charge, to any person
4 * obtaining a copy of this software and associated documentation
5 * files (the "Software"), to deal in the Software without
6 * restriction, including without limitation the rights to use, copy,
7 * modify, merge, publish, distribute, sublicense, and/or sell copies
8 * of the Software, and to permit persons to whom the Software is
9 * furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice shall be
12 * included in all copies or substantial portions of the Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
15 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
16 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
17 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
18 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
19 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
20 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 * SOFTWARE.
22 *
23 * Copyright:
24 * 2020 Evan Nemerson <evan@nemerson.com>
25 * 2020 Christopher Moore <moore@free.fr>
26 */
27
28 #if !defined(SIMDE_ARM_NEON_AND_H)
29 #define SIMDE_ARM_NEON_AND_H
30
31 #include "types.h"
32
33 HEDLEY_DIAGNOSTIC_PUSH
34 SIMDE_DISABLE_UNWANTED_DIAGNOSTICS
35 SIMDE_BEGIN_DECLS_
36
37 SIMDE_FUNCTION_ATTRIBUTES
38 simde_int8x8_t
simde_vand_s8(simde_int8x8_t a,simde_int8x8_t b)39 simde_vand_s8(simde_int8x8_t a, simde_int8x8_t b) {
40 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
41 return vand_s8(a, b);
42 #elif defined(SIMDE_X86_MMX_NATIVE)
43 return _mm_and_si64(a, b);
44 #else
45 simde_int8x8_private
46 r_,
47 a_ = simde_int8x8_to_private(a),
48 b_ = simde_int8x8_to_private(b);
49
50 #if defined(SIMDE_VECTOR_SUBSCRIPT_OPS)
51 r_.values = a_.values & b_.values;
52 #else
53 SIMDE_VECTORIZE
54 for (size_t i = 0 ; i < (sizeof(r_.values) / sizeof(r_.values[0])) ; i++) {
55 r_.values[i] = a_.values[i] & b_.values[i];
56 }
57 #endif
58
59 return simde_int8x8_from_private(r_);
60 #endif
61 }
62 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
63 #undef vand_s8
64 #define vand_s8(a, b) simde_vand_s8((a), (b))
65 #endif
66
67 SIMDE_FUNCTION_ATTRIBUTES
68 simde_int16x4_t
simde_vand_s16(simde_int16x4_t a,simde_int16x4_t b)69 simde_vand_s16(simde_int16x4_t a, simde_int16x4_t b) {
70 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
71 return vand_s16(a, b);
72 #elif defined(SIMDE_X86_MMX_NATIVE)
73 return _mm_and_si64(a, b);
74 #else
75 simde_int16x4_private
76 r_,
77 a_ = simde_int16x4_to_private(a),
78 b_ = simde_int16x4_to_private(b);
79
80 #if defined(SIMDE_VECTOR_SUBSCRIPT_OPS)
81 r_.values = a_.values & b_.values;
82 #else
83 SIMDE_VECTORIZE
84 for (size_t i = 0 ; i < (sizeof(r_.values) / sizeof(r_.values[0])) ; i++) {
85 r_.values[i] = a_.values[i] & b_.values[i];
86 }
87 #endif
88
89 return simde_int16x4_from_private(r_);
90 #endif
91 }
92 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
93 #undef vand_s16
94 #define vand_s16(a, b) simde_vand_s16((a), (b))
95 #endif
96
97 SIMDE_FUNCTION_ATTRIBUTES
98 simde_int32x2_t
simde_vand_s32(simde_int32x2_t a,simde_int32x2_t b)99 simde_vand_s32(simde_int32x2_t a, simde_int32x2_t b) {
100 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
101 return vand_s32(a, b);
102 #elif defined(SIMDE_X86_MMX_NATIVE)
103 return _mm_and_si64(a, b);
104 #else
105 simde_int32x2_private
106 r_,
107 a_ = simde_int32x2_to_private(a),
108 b_ = simde_int32x2_to_private(b);
109
110 #if defined(SIMDE_VECTOR_SUBSCRIPT_OPS)
111 r_.values = a_.values & b_.values;
112 #else
113 SIMDE_VECTORIZE
114 for (size_t i = 0 ; i < (sizeof(r_.values) / sizeof(r_.values[0])) ; i++) {
115 r_.values[i] = a_.values[i] & b_.values[i];
116 }
117 #endif
118
119 return simde_int32x2_from_private(r_);
120 #endif
121 }
122 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
123 #undef vand_s32
124 #define vand_s32(a, b) simde_vand_s32((a), (b))
125 #endif
126
127 SIMDE_FUNCTION_ATTRIBUTES
128 simde_int64x1_t
simde_vand_s64(simde_int64x1_t a,simde_int64x1_t b)129 simde_vand_s64(simde_int64x1_t a, simde_int64x1_t b) {
130 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
131 return vand_s64(a, b);
132 #elif defined(SIMDE_X86_MMX_NATIVE)
133 return _mm_and_si64(a, b);
134 #else
135 simde_int64x1_private
136 r_,
137 a_ = simde_int64x1_to_private(a),
138 b_ = simde_int64x1_to_private(b);
139
140 #if defined(SIMDE_VECTOR_SUBSCRIPT_OPS)
141 r_.values = a_.values & b_.values;
142 #else
143 SIMDE_VECTORIZE
144 for (size_t i = 0 ; i < (sizeof(r_.values) / sizeof(r_.values[0])) ; i++) {
145 r_.values[i] = a_.values[i] & b_.values[i];
146 }
147 #endif
148
149 return simde_int64x1_from_private(r_);
150 #endif
151 }
152 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
153 #undef vand_s64
154 #define vand_s64(a, b) simde_vand_s64((a), (b))
155 #endif
156
157 SIMDE_FUNCTION_ATTRIBUTES
158 simde_uint8x8_t
simde_vand_u8(simde_uint8x8_t a,simde_uint8x8_t b)159 simde_vand_u8(simde_uint8x8_t a, simde_uint8x8_t b) {
160 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
161 return vand_u8(a, b);
162 #elif defined(SIMDE_X86_MMX_NATIVE)
163 return _mm_and_si64(a, b);
164 #else
165 simde_uint8x8_private
166 r_,
167 a_ = simde_uint8x8_to_private(a),
168 b_ = simde_uint8x8_to_private(b);
169
170 #if defined(SIMDE_VECTOR_SUBSCRIPT_OPS)
171 r_.values = a_.values & b_.values;
172 #else
173 SIMDE_VECTORIZE
174 for (size_t i = 0 ; i < (sizeof(r_.values) / sizeof(r_.values[0])) ; i++) {
175 r_.values[i] = a_.values[i] & b_.values[i];
176 }
177 #endif
178
179 return simde_uint8x8_from_private(r_);
180 #endif
181 }
182 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
183 #undef vand_u8
184 #define vand_u8(a, b) simde_vand_u8((a), (b))
185 #endif
186
187 SIMDE_FUNCTION_ATTRIBUTES
188 simde_uint16x4_t
simde_vand_u16(simde_uint16x4_t a,simde_uint16x4_t b)189 simde_vand_u16(simde_uint16x4_t a, simde_uint16x4_t b) {
190 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
191 return vand_u16(a, b);
192 #elif defined(SIMDE_X86_MMX_NATIVE)
193 return _mm_and_si64(a, b);
194 #else
195 simde_uint16x4_private
196 r_,
197 a_ = simde_uint16x4_to_private(a),
198 b_ = simde_uint16x4_to_private(b);
199
200 #if defined(SIMDE_VECTOR_SUBSCRIPT_OPS)
201 r_.values = a_.values & b_.values;
202 #else
203 SIMDE_VECTORIZE
204 for (size_t i = 0 ; i < (sizeof(r_.values) / sizeof(r_.values[0])) ; i++) {
205 r_.values[i] = a_.values[i] & b_.values[i];
206 }
207 #endif
208
209 return simde_uint16x4_from_private(r_);
210 #endif
211 }
212 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
213 #undef vand_u16
214 #define vand_u16(a, b) simde_vand_u16((a), (b))
215 #endif
216
217 SIMDE_FUNCTION_ATTRIBUTES
218 simde_uint32x2_t
simde_vand_u32(simde_uint32x2_t a,simde_uint32x2_t b)219 simde_vand_u32(simde_uint32x2_t a, simde_uint32x2_t b) {
220 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
221 return vand_u32(a, b);
222 #elif defined(SIMDE_X86_MMX_NATIVE)
223 return _mm_and_si64(a, b);
224 #else
225 simde_uint32x2_private
226 r_,
227 a_ = simde_uint32x2_to_private(a),
228 b_ = simde_uint32x2_to_private(b);
229
230 #if defined(SIMDE_VECTOR_SUBSCRIPT_OPS)
231 r_.values = a_.values & b_.values;
232 #else
233 SIMDE_VECTORIZE
234 for (size_t i = 0 ; i < (sizeof(r_.values) / sizeof(r_.values[0])) ; i++) {
235 r_.values[i] = a_.values[i] & b_.values[i];
236 }
237 #endif
238
239 return simde_uint32x2_from_private(r_);
240 #endif
241 }
242 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
243 #undef vand_u32
244 #define vand_u32(a, b) simde_vand_u32((a), (b))
245 #endif
246
247 SIMDE_FUNCTION_ATTRIBUTES
248 simde_uint64x1_t
simde_vand_u64(simde_uint64x1_t a,simde_uint64x1_t b)249 simde_vand_u64(simde_uint64x1_t a, simde_uint64x1_t b) {
250 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
251 return vand_u64(a, b);
252 #elif defined(SIMDE_X86_MMX_NATIVE)
253 return _mm_and_si64(a, b);
254 #else
255 simde_uint64x1_private
256 r_,
257 a_ = simde_uint64x1_to_private(a),
258 b_ = simde_uint64x1_to_private(b);
259
260 #if defined(SIMDE_VECTOR_SUBSCRIPT_OPS)
261 r_.values = a_.values & b_.values;
262 #else
263 SIMDE_VECTORIZE
264 for (size_t i = 0 ; i < (sizeof(r_.values) / sizeof(r_.values[0])) ; i++) {
265 r_.values[i] = a_.values[i] & b_.values[i];
266 }
267 #endif
268
269 return simde_uint64x1_from_private(r_);
270 #endif
271 }
272 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
273 #undef vand_u64
274 #define vand_u64(a, b) simde_vand_u64((a), (b))
275 #endif
276
277 SIMDE_FUNCTION_ATTRIBUTES
278 simde_int8x16_t
simde_vandq_s8(simde_int8x16_t a,simde_int8x16_t b)279 simde_vandq_s8(simde_int8x16_t a, simde_int8x16_t b) {
280 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
281 return vandq_s8(a, b);
282 #elif defined(SIMDE_X86_SSE2_NATIVE)
283 return _mm_and_si128(a, b);
284 #elif defined(SIMDE_POWER_ALTIVEC_P5_NATIVE)
285 return vec_and(a, b);
286 #elif defined(SIMDE_WASM_SIMD128_NATIVE)
287 return wasm_v128_and(a, b);
288 #else
289 simde_int8x16_private
290 r_,
291 a_ = simde_int8x16_to_private(a),
292 b_ = simde_int8x16_to_private(b);
293
294 #if defined(SIMDE_VECTOR_SUBSCRIPT_OPS)
295 r_.values = a_.values & b_.values;
296 #else
297 SIMDE_VECTORIZE
298 for (size_t i = 0 ; i < (sizeof(r_.values) / sizeof(r_.values[0])) ; i++) {
299 r_.values[i] = a_.values[i] & b_.values[i];
300 }
301 #endif
302
303 return simde_int8x16_from_private(r_);
304 #endif
305 }
306 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
307 #undef vandq_s8
308 #define vandq_s8(a, b) simde_vandq_s8((a), (b))
309 #endif
310
311 SIMDE_FUNCTION_ATTRIBUTES
312 simde_int16x8_t
simde_vandq_s16(simde_int16x8_t a,simde_int16x8_t b)313 simde_vandq_s16(simde_int16x8_t a, simde_int16x8_t b) {
314 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
315 return vandq_s16(a, b);
316 #elif defined(SIMDE_X86_SSE2_NATIVE)
317 return _mm_and_si128(a, b);
318 #elif defined(SIMDE_POWER_ALTIVEC_P5_NATIVE)
319 return vec_and(a, b);
320 #elif defined(SIMDE_WASM_SIMD128_NATIVE)
321 return wasm_v128_and(a, b);
322 #else
323 simde_int16x8_private
324 r_,
325 a_ = simde_int16x8_to_private(a),
326 b_ = simde_int16x8_to_private(b);
327
328 #if defined(SIMDE_VECTOR_SUBSCRIPT_OPS)
329 r_.values = a_.values & b_.values;
330 #else
331 SIMDE_VECTORIZE
332 for (size_t i = 0 ; i < (sizeof(r_.values) / sizeof(r_.values[0])) ; i++) {
333 r_.values[i] = a_.values[i] & b_.values[i];
334 }
335 #endif
336
337 return simde_int16x8_from_private(r_);
338 #endif
339 }
340 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
341 #undef vandq_s16
342 #define vandq_s16(a, b) simde_vandq_s16((a), (b))
343 #endif
344
345 SIMDE_FUNCTION_ATTRIBUTES
346 simde_int32x4_t
simde_vandq_s32(simde_int32x4_t a,simde_int32x4_t b)347 simde_vandq_s32(simde_int32x4_t a, simde_int32x4_t b) {
348 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
349 return vandq_s32(a, b);
350 #elif defined(SIMDE_X86_SSE2_NATIVE)
351 return _mm_and_si128(a, b);
352 #elif defined(SIMDE_POWER_ALTIVEC_P5_NATIVE)
353 return vec_and(a, b);
354 #elif defined(SIMDE_WASM_SIMD128_NATIVE)
355 return wasm_v128_and(a, b);
356 #else
357 simde_int32x4_private
358 r_,
359 a_ = simde_int32x4_to_private(a),
360 b_ = simde_int32x4_to_private(b);
361
362 #if defined(SIMDE_VECTOR_SUBSCRIPT_OPS)
363 r_.values = a_.values & b_.values;
364 #else
365 SIMDE_VECTORIZE
366 for (size_t i = 0 ; i < (sizeof(r_.values) / sizeof(r_.values[0])) ; i++) {
367 r_.values[i] = a_.values[i] & b_.values[i];
368 }
369 #endif
370
371 return simde_int32x4_from_private(r_);
372 #endif
373 }
374 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
375 #undef vandq_s32
376 #define vandq_s32(a, b) simde_vandq_s32((a), (b))
377 #endif
378
379 SIMDE_FUNCTION_ATTRIBUTES
380 simde_int64x2_t
simde_vandq_s64(simde_int64x2_t a,simde_int64x2_t b)381 simde_vandq_s64(simde_int64x2_t a, simde_int64x2_t b) {
382 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
383 return vandq_s64(a, b);
384 #elif defined(SIMDE_X86_SSE2_NATIVE)
385 return _mm_and_si128(a, b);
386 #elif defined(SIMDE_POWER_ALTIVEC_P7_NATIVE)
387 return vec_and(a, b);
388 #elif defined(SIMDE_WASM_SIMD128_NATIVE)
389 return wasm_v128_and(a, b);
390 #else
391 simde_int64x2_private
392 r_,
393 a_ = simde_int64x2_to_private(a),
394 b_ = simde_int64x2_to_private(b);
395
396 #if defined(SIMDE_VECTOR_SUBSCRIPT_OPS)
397 r_.values = a_.values & b_.values;
398 #else
399 SIMDE_VECTORIZE
400 for (size_t i = 0 ; i < (sizeof(r_.values) / sizeof(r_.values[0])) ; i++) {
401 r_.values[i] = a_.values[i] & b_.values[i];
402 }
403 #endif
404
405 return simde_int64x2_from_private(r_);
406 #endif
407 }
408 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
409 #undef vandq_s64
410 #define vandq_s64(a, b) simde_vandq_s64((a), (b))
411 #endif
412
413 SIMDE_FUNCTION_ATTRIBUTES
414 simde_uint8x16_t
simde_vandq_u8(simde_uint8x16_t a,simde_uint8x16_t b)415 simde_vandq_u8(simde_uint8x16_t a, simde_uint8x16_t b) {
416 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
417 return vandq_u8(a, b);
418 #elif defined(SIMDE_X86_SSE2_NATIVE)
419 return _mm_and_si128(a, b);
420 #elif defined(SIMDE_POWER_ALTIVEC_P5_NATIVE)
421 return vec_and(a, b);
422 #elif defined(SIMDE_WASM_SIMD128_NATIVE)
423 return wasm_v128_and(a, b);
424 #else
425 simde_uint8x16_private
426 r_,
427 a_ = simde_uint8x16_to_private(a),
428 b_ = simde_uint8x16_to_private(b);
429
430 #if defined(SIMDE_VECTOR_SUBSCRIPT_OPS)
431 r_.values = a_.values & b_.values;
432 #else
433 SIMDE_VECTORIZE
434 for (size_t i = 0 ; i < (sizeof(r_.values) / sizeof(r_.values[0])) ; i++) {
435 r_.values[i] = a_.values[i] & b_.values[i];
436 }
437 #endif
438
439 return simde_uint8x16_from_private(r_);
440 #endif
441 }
442 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
443 #undef vandq_u8
444 #define vandq_u8(a, b) simde_vandq_u8((a), (b))
445 #endif
446
447 SIMDE_FUNCTION_ATTRIBUTES
448 simde_uint16x8_t
simde_vandq_u16(simde_uint16x8_t a,simde_uint16x8_t b)449 simde_vandq_u16(simde_uint16x8_t a, simde_uint16x8_t b) {
450 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
451 return vandq_u16(a, b);
452 #elif defined(SIMDE_X86_SSE2_NATIVE)
453 return _mm_and_si128(a, b);
454 #elif defined(SIMDE_POWER_ALTIVEC_P5_NATIVE)
455 return vec_and(a, b);
456 #elif defined(SIMDE_WASM_SIMD128_NATIVE)
457 return wasm_v128_and(a, b);
458 #else
459 simde_uint16x8_private
460 r_,
461 a_ = simde_uint16x8_to_private(a),
462 b_ = simde_uint16x8_to_private(b);
463
464 #if defined(SIMDE_VECTOR_SUBSCRIPT_OPS)
465 r_.values = a_.values & b_.values;
466 #else
467 SIMDE_VECTORIZE
468 for (size_t i = 0 ; i < (sizeof(r_.values) / sizeof(r_.values[0])) ; i++) {
469 r_.values[i] = a_.values[i] & b_.values[i];
470 }
471 #endif
472
473 return simde_uint16x8_from_private(r_);
474 #endif
475 }
476 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
477 #undef vandq_u16
478 #define vandq_u16(a, b) simde_vandq_u16((a), (b))
479 #endif
480
481 SIMDE_FUNCTION_ATTRIBUTES
482 simde_uint32x4_t
simde_vandq_u32(simde_uint32x4_t a,simde_uint32x4_t b)483 simde_vandq_u32(simde_uint32x4_t a, simde_uint32x4_t b) {
484 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
485 return vandq_u32(a, b);
486 #elif defined(SIMDE_X86_SSE2_NATIVE)
487 return _mm_and_si128(a, b);
488 #elif defined(SIMDE_POWER_ALTIVEC_P5_NATIVE)
489 return vec_and(a, b);
490 #elif defined(SIMDE_WASM_SIMD128_NATIVE)
491 return wasm_v128_and(a, b);
492 #else
493 simde_uint32x4_private
494 r_,
495 a_ = simde_uint32x4_to_private(a),
496 b_ = simde_uint32x4_to_private(b);
497
498 #if defined(SIMDE_VECTOR_SUBSCRIPT_OPS)
499 r_.values = a_.values & b_.values;
500 #else
501 SIMDE_VECTORIZE
502 for (size_t i = 0 ; i < (sizeof(r_.values) / sizeof(r_.values[0])) ; i++) {
503 r_.values[i] = a_.values[i] & b_.values[i];
504 }
505 #endif
506
507 return simde_uint32x4_from_private(r_);
508 #endif
509 }
510 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
511 #undef vandq_u32
512 #define vandq_u32(a, b) simde_vandq_u32((a), (b))
513 #endif
514
515 SIMDE_FUNCTION_ATTRIBUTES
516 simde_uint64x2_t
simde_vandq_u64(simde_uint64x2_t a,simde_uint64x2_t b)517 simde_vandq_u64(simde_uint64x2_t a, simde_uint64x2_t b) {
518 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
519 return vandq_u64(a, b);
520 #elif defined(SIMDE_X86_SSE2_NATIVE)
521 return _mm_and_si128(a, b);
522 #elif defined(SIMDE_POWER_ALTIVEC_P7_NATIVE)
523 return vec_and(a, b);
524 #elif defined(SIMDE_WASM_SIMD128_NATIVE)
525 return wasm_v128_and(a, b);
526 #else
527 simde_uint64x2_private
528 r_,
529 a_ = simde_uint64x2_to_private(a),
530 b_ = simde_uint64x2_to_private(b);
531
532 #if defined(SIMDE_VECTOR_SUBSCRIPT_OPS)
533 r_.values = a_.values & b_.values;
534 #else
535 SIMDE_VECTORIZE
536 for (size_t i = 0 ; i < (sizeof(r_.values) / sizeof(r_.values[0])) ; i++) {
537 r_.values[i] = a_.values[i] & b_.values[i];
538 }
539 #endif
540
541 return simde_uint64x2_from_private(r_);
542 #endif
543 }
544 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
545 #undef vandq_u64
546 #define vandq_u64(a, b) simde_vandq_u64((a), (b))
547 #endif
548
549 SIMDE_END_DECLS_
550 HEDLEY_DIAGNOSTIC_POP
551
552 #endif /* !defined(SIMDE_ARM_NEON_AND_H) */
553