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