1 /*===---- avxintrin.h - AVX intrinsics -------------------------------------===
5  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7  *===-----------------------------------------------------------------------===
54   __attribute__((__always_inline__, __nodebug__, __target__("avx,no-evex512"), \
57   __attribute__((__always_inline__, __nodebug__, __target__("avx,no-evex512"), \
61 /// Adds two 256-bit vectors of [4 x double].
68 ///    A 256-bit vector of [4 x double] containing one of the source operands.
70 ///    A 256-bit vector of [4 x double] containing one of the source operands.
71 /// \returns A 256-bit vector of [4 x double] containing the sums of both
79 /// Adds two 256-bit vectors of [8 x float].
86 ///    A 256-bit vector of [8 x float] containing one of the source operands.
88 ///    A 256-bit vector of [8 x float] containing one of the source operands.
89 /// \returns A 256-bit vector of [8 x float] containing the sums of both
97 /// Subtracts two 256-bit vectors of [4 x double].
104 ///    A 256-bit vector of [4 x double] containing the minuend.
106 ///    A 256-bit vector of [4 x double] containing the subtrahend.
107 /// \returns A 256-bit vector of [4 x double] containing the differences between
112   return (__m256d)((__v4df)__a-(__v4df)__b);  in _mm256_sub_pd()
115 /// Subtracts two 256-bit vectors of [8 x float].
122 ///    A 256-bit vector of [8 x float] containing the minuend.
124 ///    A 256-bit vector of [8 x float] containing the subtrahend.
125 /// \returns A 256-bit vector of [8 x float] containing the differences between
130   return (__m256)((__v8sf)__a-(__v8sf)__b);  in _mm256_sub_ps()
133 /// Adds the even-indexed values and subtracts the odd-indexed values of
134 ///    two 256-bit vectors of [4 x double].
141 ///    A 256-bit vector of [4 x double] containing the left source operand.
143 ///    A 256-bit vector of [4 x double] containing the right source operand.
144 /// \returns A 256-bit vector of [4 x double] containing the alternating sums
152 /// Adds the even-indexed values and subtracts the odd-indexed values of
153 ///    two 256-bit vectors of [8 x float].
160 ///    A 256-bit vector of [8 x float] containing the left source operand.
162 ///    A 256-bit vector of [8 x float] containing the right source operand.
163 /// \returns A 256-bit vector of [8 x float] containing the alternating sums and
171 /// Divides two 256-bit vectors of [4 x double].
178 ///    A 256-bit vector of [4 x double] containing the dividend.
180 ///    A 256-bit vector of [4 x double] containing the divisor.
181 /// \returns A 256-bit vector of [4 x double] containing the quotients of both
189 /// Divides two 256-bit vectors of [8 x float].
196 ///    A 256-bit vector of [8 x float] containing the dividend.
198 ///    A 256-bit vector of [8 x float] containing the divisor.
199 /// \returns A 256-bit vector of [8 x float] containing the quotients of both
207 /// Compares two 256-bit vectors of [4 x double] and returns the greater
217 ///    A 256-bit vector of [4 x double] containing one of the operands.
219 ///    A 256-bit vector of [4 x double] containing one of the operands.
220 /// \returns A 256-bit vector of [4 x double] containing the maximum values
228 /// Compares two 256-bit vectors of [8 x float] and returns the greater
238 ///    A 256-bit vector of [8 x float] containing one of the operands.
240 ///    A 256-bit vector of [8 x float] containing one of the operands.
241 /// \returns A 256-bit vector of [8 x float] containing the maximum values
249 /// Compares two 256-bit vectors of [4 x double] and returns the lesser
259 ///    A 256-bit vector of [4 x double] containing one of the operands.
261 ///    A 256-bit vector of [4 x double] containing one of the operands.
262 /// \returns A 256-bit vector of [4 x double] containing the minimum values
270 /// Compares two 256-bit vectors of [8 x float] and returns the lesser
280 ///    A 256-bit vector of [8 x float] containing one of the operands.
282 ///    A 256-bit vector of [8 x float] containing one of the operands.
283 /// \returns A 256-bit vector of [8 x float] containing the minimum values
291 /// Multiplies two 256-bit vectors of [4 x double].
298 ///    A 256-bit vector of [4 x double] containing one of the operands.
300 ///    A 256-bit vector of [4 x double] containing one of the operands.
301 /// \returns A 256-bit vector of [4 x double] containing the products of both
309 /// Multiplies two 256-bit vectors of [8 x float].
316 ///    A 256-bit vector of [8 x float] containing one of the operands.
318 ///    A 256-bit vector of [8 x float] containing one of the operands.
319 /// \returns A 256-bit vector of [8 x float] containing the products of both
327 /// Calculates the square roots of the values in a 256-bit vector of
335 ///    A 256-bit vector of [4 x double].
336 /// \returns A 256-bit vector of [4 x double] containing the square roots of the
344 /// Calculates the square roots of the values in a 256-bit vector of
352 ///    A 256-bit vector of [8 x float].
353 /// \returns A 256-bit vector of [8 x float] containing the square roots of the
361 /// Calculates the reciprocal square roots of the values in a 256-bit
369 ///    A 256-bit vector of [8 x float].
370 /// \returns A 256-bit vector of [8 x float] containing the reciprocal square
378 /// Calculates the reciprocals of the values in a 256-bit vector of
386 ///    A 256-bit vector of [8 x float].
387 /// \returns A 256-bit vector of [8 x float] containing the reciprocals of the
395 /// Rounds the values in a 256-bit vector of [4 x double] as specified
396 ///    by the byte operand. The source values are rounded to integer values and
397 ///    returned as 64-bit double-precision floating-point values.
408 ///    A 256-bit vector of [4 x double].
410 ///    An integer value that specifies the rounding operation. \n
411 ///    Bits [7:4] are reserved. \n
412 ///    Bit [3] is a precision exception value: \n
413 ///      0: A normal PE exception is used. \n
414 ///      1: The PE field is not updated. \n
415 ///    Bit [2] is the rounding control source: \n
416 ///      0: Use bits [1:0] of \a M. \n
417 ///      1: Use the current MXCSR setting. \n
418 ///    Bits [1:0] contain the rounding control definition: \n
419 ///      00: Nearest. \n
420 ///      01: Downward (toward negative infinity). \n
421 ///      10: Upward (toward positive infinity). \n
423 /// \returns A 256-bit vector of [4 x double] containing the rounded values.
427 /// Rounds the values stored in a 256-bit vector of [8 x float] as
428 ///    specified by the byte operand. The source values are rounded to integer
429 ///    values and returned as floating-point values.
440 ///    A 256-bit vector of [8 x float].
442 ///    An integer value that specifies the rounding operation. \n
443 ///    Bits [7:4] are reserved. \n
444 ///    Bit [3] is a precision exception value: \n
445 ///      0: A normal PE exception is used. \n
446 ///      1: The PE field is not updated. \n
447 ///    Bit [2] is the rounding control source: \n
448 ///      0: Use bits [1:0] of \a M. \n
449 ///      1: Use the current MXCSR setting. \n
450 ///    Bits [1:0] contain the rounding control definition: \n
451 ///      00: Nearest. \n
452 ///      01: Downward (toward negative infinity). \n
453 ///      10: Upward (toward positive infinity). \n
455 /// \returns A 256-bit vector of [8 x float] containing the rounded values.
459 /// Rounds up the values stored in a 256-bit vector of [4 x double]. The
460 ///    source values are rounded up to integer values and returned as 64-bit
461 ///    double-precision floating-point values.
472 ///    A 256-bit vector of [4 x double].
473 /// \returns A 256-bit vector of [4 x double] containing the rounded up values.
476 /// Rounds down the values stored in a 256-bit vector of [4 x double].
477 ///    The source values are rounded down to integer values and returned as
478 ///    64-bit double-precision floating-point values.
489 ///    A 256-bit vector of [4 x double].
490 /// \returns A 256-bit vector of [4 x double] containing the rounded down
494 /// Rounds up the values stored in a 256-bit vector of [8 x float]. The
495 ///    source values are rounded up to integer values and returned as
496 ///    floating-point values.
507 ///    A 256-bit vector of [8 x float].
508 /// \returns A 256-bit vector of [8 x float] containing the rounded up values.
511 /// Rounds down the values stored in a 256-bit vector of [8 x float]. The
512 ///    source values are rounded down to integer values and returned as
513 ///    floating-point values.
524 ///    A 256-bit vector of [8 x float].
525 /// \returns A 256-bit vector of [8 x float] containing the rounded down values.
529 /// Performs a bitwise AND of two 256-bit vectors of [4 x double].
536 ///    A 256-bit vector of [4 x double] containing one of the source operands.
538 ///    A 256-bit vector of [4 x double] containing one of the source operands.
539 /// \returns A 256-bit vector of [4 x double] containing the bitwise AND of the
547 /// Performs a bitwise AND of two 256-bit vectors of [8 x float].
554 ///    A 256-bit vector of [8 x float] containing one of the source operands.
556 ///    A 256-bit vector of [8 x float] containing one of the source operands.
557 /// \returns A 256-bit vector of [8 x float] containing the bitwise AND of the
565 /// Performs a bitwise AND of two 256-bit vectors of [4 x double], using
573 ///    A 256-bit vector of [4 x double] containing the left source operand. The
576 ///    A 256-bit vector of [4 x double] containing the right source operand.
577 /// \returns A 256-bit vector of [4 x double] containing the bitwise AND of the
586 /// Performs a bitwise AND of two 256-bit vectors of [8 x float], using
594 ///    A 256-bit vector of [8 x float] containing the left source operand. The
597 ///    A 256-bit vector of [8 x float] containing the right source operand.
598 /// \returns A 256-bit vector of [8 x float] containing the bitwise AND of the
607 /// Performs a bitwise OR of two 256-bit vectors of [4 x double].
614 ///    A 256-bit vector of [4 x double] containing one of the source operands.
616 ///    A 256-bit vector of [4 x double] containing one of the source operands.
617 /// \returns A 256-bit vector of [4 x double] containing the bitwise OR of the
625 /// Performs a bitwise OR of two 256-bit vectors of [8 x float].
632 ///    A 256-bit vector of [8 x float] containing one of the source operands.
634 ///    A 256-bit vector of [8 x float] containing one of the source operands.
635 /// \returns A 256-bit vector of [8 x float] containing the bitwise OR of the
643 /// Performs a bitwise XOR of two 256-bit vectors of [4 x double].
650 ///    A 256-bit vector of [4 x double] containing one of the source operands.
652 ///    A 256-bit vector of [4 x double] containing one of the source operands.
653 /// \returns A 256-bit vector of [4 x double] containing the bitwise XOR of the
661 /// Performs a bitwise XOR of two 256-bit vectors of [8 x float].
668 ///    A 256-bit vector of [8 x float] containing one of the source operands.
670 ///    A 256-bit vector of [8 x float] containing one of the source operands.
671 /// \returns A 256-bit vector of [8 x float] containing the bitwise XOR of the
681 ///    256-bit vectors of [4 x double].
688 ///    A 256-bit vector of [4 x double] containing one of the source operands.
689 ///    The horizontal sums of the values are returned in the even-indexed
692 ///    A 256-bit vector of [4 x double] containing one of the source operands.
693 ///    The horizontal sums of the values are returned in the odd-indexed
695 /// \returns A 256-bit vector of [4 x double] containing the horizontal sums of
704 ///    256-bit vectors of [8 x float].
711 ///    A 256-bit vector of [8 x float] containing one of the source operands.
715 ///    A 256-bit vector of [8 x float] containing one of the source operands.
718 /// \returns A 256-bit vector of [8 x float] containing the horizontal sums of
727 ///    256-bit vectors of [4 x double].
734 ///    A 256-bit vector of [4 x double] containing one of the source operands.
736 ///    even-indexed elements of a vector of [4 x double].
738 ///    A 256-bit vector of [4 x double] containing one of the source operands.
740 ///    odd-indexed elements of a vector of [4 x double].
741 /// \returns A 256-bit vector of [4 x double] containing the horizontal
750 ///    256-bit vectors of [8 x float].
757 ///    A 256-bit vector of [8 x float] containing one of the source operands.
761 ///    A 256-bit vector of [8 x float] containing one of the source operands.
764 /// \returns A 256-bit vector of [8 x float] containing the horizontal
773 /// Copies the values in a 128-bit vector of [2 x double] as specified
774 ///    by the 128-bit integer vector operand.
781 ///    A 128-bit vector of [2 x double].
783 ///    A 128-bit integer vector operand specifying how the values are to be
784 ///    copied. \n
785 ///    Bit [1]: \n
787 ///         vector. \n
789 ///         returned vector. \n
790 ///    Bit [65]: \n
792 ///         returned vector. \n
795 /// \returns A 128-bit vector of [2 x double] containing the copied values.
802 /// Copies the values in a 256-bit vector of [4 x double] as specified
803 ///    by the 256-bit integer vector operand.
810 ///    A 256-bit vector of [4 x double].
812 ///    A 256-bit integer vector operand specifying how the values are to be
813 ///    copied. \n
814 ///    Bit [1]: \n
816 ///         vector. \n
818 ///         returned vector. \n
819 ///    Bit [65]: \n
821 ///         returned vector. \n
823 ///         returned vector. \n
824 ///    Bit [129]: \n
826 ///         returned vector. \n
828 ///         returned vector. \n
829 ///    Bit [193]: \n
831 ///         returned vector. \n
834 /// \returns A 256-bit vector of [4 x double] containing the copied values.
841 /// Copies the values stored in a 128-bit vector of [4 x float] as
842 ///    specified by the 128-bit integer vector operand.
849 ///    A 128-bit vector of [4 x float].
851 ///    A 128-bit integer vector operand specifying how the values are to be
852 ///    copied. \n
853 ///    Bits [1:0]: \n
855 ///          returned vector. \n
857 ///          returned vector. \n
859 ///          returned vector. \n
861 ///          returned vector. \n
862 ///    Bits [33:32]: \n
864 ///          returned vector. \n
866 ///          returned vector. \n
868 ///          returned vector. \n
870 ///          returned vector. \n
871 ///    Bits [65:64]: \n
873 ///          returned vector. \n
875 ///          returned vector. \n
877 ///          returned vector. \n
879 ///          returned vector. \n
880 ///    Bits [97:96]: \n
882 ///          returned vector. \n
884 ///          returned vector. \n
886 ///          returned vector. \n
889 /// \returns A 128-bit vector of [4 x float] containing the copied values.
896 /// Copies the values stored in a 256-bit vector of [8 x float] as
897 ///    specified by the 256-bit integer vector operand.
904 ///    A 256-bit vector of [8 x float].
906 ///    A 256-bit integer vector operand specifying how the values are to be
907 ///    copied. \n
908 ///    Bits [1:0]: \n
910 ///          returned vector. \n
912 ///          returned vector. \n
914 ///          returned vector. \n
916 ///          returned vector. \n
917 ///    Bits [33:32]: \n
919 ///          returned vector. \n
921 ///          returned vector. \n
923 ///          returned vector. \n
925 ///          returned vector. \n
926 ///    Bits [65:64]: \n
928 ///          returned vector. \n
930 ///          returned vector. \n
932 ///          returned vector. \n
934 ///          returned vector. \n
935 ///    Bits [97:96]: \n
937 ///          returned vector. \n
939 ///          returned vector. \n
941 ///          returned vector. \n
943 ///          returned vector. \n
944 ///    Bits [129:128]: \n
946 ///          returned vector. \n
948 ///          returned vector. \n
950 ///          returned vector. \n
952 ///          returned vector. \n
953 ///    Bits [161:160]: \n
955 ///          returned vector. \n
957 ///          returned vector. \n
959 ///          returned vector. \n
961 ///          returned vector. \n
962 ///    Bits [193:192]: \n
964 ///          returned vector. \n
966 ///          returned vector. \n
968 ///          returned vector. \n
970 ///          returned vector. \n
971 ///    Bits [225:224]: \n
973 ///          returned vector. \n
975 ///          returned vector. \n
977 ///          returned vector. \n
980 /// \returns A 256-bit vector of [8 x float] containing the copied values.
987 /// Copies the values in a 128-bit vector of [2 x double] as specified
988 ///    by the immediate integer operand.
999 ///    A 128-bit vector of [2 x double].
1001 ///    An immediate integer operand specifying how the values are to be
1002 ///    copied. \n
1003 ///    Bit [0]: \n
1005 ///         vector. \n
1007 ///         returned vector. \n
1008 ///    Bit [1]: \n
1010 ///         returned vector. \n
1013 /// \returns A 128-bit vector of [2 x double] containing the copied values.
1017 /// Copies the values in a 256-bit vector of [4 x double] as specified by
1018 ///    the immediate integer operand.
1029 ///    A 256-bit vector of [4 x double].
1031 ///    An immediate integer operand specifying how the values are to be
1032 ///    copied. \n
1033 ///    Bit [0]: \n
1035 ///         vector. \n
1037 ///         returned vector. \n
1038 ///    Bit [1]: \n
1040 ///         returned vector. \n
1042 ///         returned vector. \n
1043 ///    Bit [2]: \n
1045 ///         returned vector. \n
1047 ///         returned vector. \n
1048 ///    Bit [3]: \n
1050 ///         returned vector. \n
1053 /// \returns A 256-bit vector of [4 x double] containing the copied values.
1057 /// Copies the values in a 128-bit vector of [4 x float] as specified by
1058 ///    the immediate integer operand.
1069 ///    A 128-bit vector of [4 x float].
1071 ///    An immediate integer operand specifying how the values are to be
1072 ///    copied. \n
1073 ///    Bits [1:0]: \n
1075 ///          returned vector. \n
1077 ///          returned vector. \n
1079 ///          returned vector. \n
1081 ///          returned vector. \n
1082 ///    Bits [3:2]: \n
1084 ///          returned vector. \n
1086 ///          returned vector. \n
1088 ///          returned vector. \n
1090 ///          returned vector. \n
1091 ///    Bits [5:4]: \n
1093 ///          returned vector. \n
1095 ///          returned vector. \n
1097 ///          returned vector. \n
1099 ///          returned vector. \n
1100 ///    Bits [7:6]: \n
1102 ///          returned vector. \n
1104 ///          returned vector. \n
1106 ///          returned vector. \n
1109 /// \returns A 128-bit vector of [4 x float] containing the copied values.
1113 /// Copies the values in a 256-bit vector of [8 x float] as specified by
1114 ///    the immediate integer operand.
1125 ///    A 256-bit vector of [8 x float].
1127 ///    An immediate integer operand specifying how the values are to be
1128 ///    copied. \n
1129 ///    Bits [1:0]: \n
1131 ///          returned vector. \n
1133 ///          returned vector. \n
1135 ///          returned vector. \n
1137 ///          returned vector. \n
1138 ///    Bits [3:2]: \n
1140 ///          returned vector. \n
1142 ///          returned vector. \n
1144 ///          returned vector. \n
1146 ///          returned vector. \n
1147 ///    Bits [5:4]: \n
1149 ///          returned vector. \n
1151 ///          returned vector. \n
1153 ///          returned vector. \n
1155 ///          returned vector. \n
1156 ///    Bits [7:6]: \n
1158 ///          returned vector. \n
1160 ///          returned vector. \n
1162 ///          returned vector. \n
1164 ///          returned vector. \n
1165 ///    Bits [1:0]: \n
1167 ///          returned vector. \n
1169 ///          returned vector. \n
1171 ///          returned vector. \n
1173 ///          returned vector. \n
1174 ///    Bits [3:2]: \n
1176 ///          returned vector. \n
1178 ///          returned vector. \n
1180 ///          returned vector. \n
1182 ///          returned vector. \n
1183 ///    Bits [5:4]: \n
1185 ///          returned vector. \n
1187 ///          returned vector. \n
1189 ///          returned vector. \n
1191 ///          returned vector. \n
1192 ///    Bits [7:6]: \n
1194 ///          returned vector. \n
1196 ///          returned vector. \n
1198 ///          returned vector. \n
1201 /// \returns A 256-bit vector of [8 x float] containing the copied values.
1205 /// Permutes 128-bit data values stored in two 256-bit vectors of
1206 ///    [4 x double], as specified by the immediate integer operand.
1217 ///    A 256-bit vector of [4 x double].
1219 ///    A 256-bit vector of [4 x double.
1221 ///    An immediate integer operand specifying how the values are to be
1222 ///    permuted. \n
1223 ///    Bits [1:0]: \n
1225 ///          destination. \n
1227 ///          destination. \n
1229 ///          destination. \n
1231 ///          destination. \n
1232 ///    Bits [5:4]: \n
1234 ///          destination. \n
1236 ///          destination. \n
1238 ///          destination. \n
1241 /// \returns A 256-bit vector of [4 x double] containing the copied values.
1246 /// Permutes 128-bit data values stored in two 256-bit vectors of
1247 ///    [8 x float], as specified by the immediate integer operand.
1258 ///    A 256-bit vector of [8 x float].
1260 ///    A 256-bit vector of [8 x float].
1262 ///    An immediate integer operand specifying how the values are to be
1263 ///    permuted. \n
1264 ///    Bits [1:0]: \n
1266 ///    destination. \n
1268 ///    destination. \n
1270 ///    destination. \n
1272 ///    destination. \n
1273 ///    Bits [5:4]: \n
1275 ///    destination. \n
1277 ///    destination. \n
1279 ///    destination. \n
1282 /// \returns A 256-bit vector of [8 x float] containing the copied values.
1287 /// Permutes 128-bit data values stored in two 256-bit integer vectors,
1288 ///    as specified by the immediate integer operand.
1299 ///    A 256-bit integer vector.
1301 ///    A 256-bit integer vector.
1303 ///    An immediate integer operand specifying how the values are to be copied.
1304 ///    Bits [1:0]: \n
1306 ///    destination. \n
1308 ///    destination. \n
1310 ///    destination. \n
1312 ///    destination. \n
1313 ///    Bits [5:4]: \n
1315 ///    destination. \n
1317 ///    destination. \n
1319 ///    destination. \n
1322 /// \returns A 256-bit integer vector containing the copied values.
1328 /// Merges 64-bit double-precision data values stored in either of the
1329 ///    two 256-bit vectors of [4 x double], as specified by the immediate
1330 ///    integer operand.
1341 ///    A 256-bit vector of [4 x double].
1343 ///    A 256-bit vector of [4 x double].
1345 ///    An immediate integer operand, with mask bits [3:0] specifying how the
1347 ///    index of a copied value. When a mask bit is 0, the corresponding 64-bit
1349 ///    destination. When a mask bit is 1, the corresponding 64-bit element in
1351 /// \returns A 256-bit vector of [4 x double] containing the copied values.
1356 /// Merges 32-bit single-precision data values stored in either of the
1357 ///    two 256-bit vectors of [8 x float], as specified by the immediate
1358 ///    integer operand.
1369 ///    A 256-bit vector of [8 x float].
1371 ///    A 256-bit vector of [8 x float].
1373 ///    An immediate integer operand, with mask bits [7:0] specifying how the
1375 ///    index of a copied value. When a mask bit is 0, the corresponding 32-bit
1377 ///    destination. When a mask bit is 1, the corresponding 32-bit element in
1379 /// \returns A 256-bit vector of [8 x float] containing the copied values.
1384 /// Merges 64-bit double-precision data values stored in either of the
1385 ///    two 256-bit vectors of [4 x double], as specified by the 256-bit vector
1393 ///    A 256-bit vector of [4 x double].
1395 ///    A 256-bit vector of [4 x double].
1397 ///    A 256-bit vector operand, with mask bits 255, 191, 127, and 63 specifying
1400 ///    corresponding 64-bit element in operand \a __a is copied to the same
1402 ///    64-bit element in operand \a __b is copied to the same position in the
1404 /// \returns A 256-bit vector of [4 x double] containing the copied values.
1412 /// Merges 32-bit single-precision data values stored in either of the
1413 ///    two 256-bit vectors of [8 x float], as specified by the 256-bit vector
1421 ///    A 256-bit vector of [8 x float].
1423 ///    A 256-bit vector of [8 x float].
1425 ///    A 256-bit vector operand, with mask bits 255, 223, 191, 159, 127, 95, 63,
1428 ///    a mask bit is 0, the corresponding 32-bit element in operand \a __a is
1430 ///    corresponding 32-bit element in operand \a __b is copied to the same
1432 /// \returns A 256-bit vector of [8 x float] containing the copied values.
1446 ///    The immediate integer operand controls which input elements will
1465 ///    An immediate integer argument. Bits [7:4] determine which elements of
1477 /// \returns A 256-bit vector of [8 x float] containing the two dot products.
1483 /// Selects 8 float values from the 256-bit operands of [8 x float], as
1488 ///    elements from the first 256-bit operand are copied to bits [63:0] and
1490 ///    second 256-bit operand are copied to bits [127:64] and bits [255:192] of
1492 ///    contain a value of 0xFF, the 256-bit destination vector would contain the
1504 ///    A 256-bit vector of [8 x float]. The four selected elements in this
1508 ///    A 256-bit vector of [8 x float]. The four selected elements in this
1512 ///    An immediate value containing an 8-bit value specifying which elements to
1513 ///    copy from \a a and \a b \n.
1514 ///    Bits [3:0] specify the values copied from operand \a a. \n
1515 ///    Bits [7:4] specify the values copied from operand \a b. \n
1516 ///    The destinations within the 256-bit destination are assigned values as
1517 ///    follows, according to the bit value assignments described below: \n
1519 ///    destination. \n
1521 ///    destination. \n
1523 ///    destination. \n
1525 ///    the destination. \n
1526 ///    Bit value assignments: \n
1527 ///    00: Bits [31:0] and [159:128] are copied from the selected operand. \n
1528 ///    01: Bits [63:32] and [191:160] are copied from the selected operand. \n
1529 ///    10: Bits [95:64] and [223:192] are copied from the selected operand. \n
1530 ///    11: Bits [127:96] and [255:224] are copied from the selected operand. \n
1532 ///    <c>_MM_SHUFFLE(b6, b4, b2, b0)</c> can create an 8-bit mask of the form
1534 /// \returns A 256-bit vector of [8 x float] containing the shuffled values.
1539 /// Selects four double-precision values from the 256-bit operands of
1542 ///    The selected elements from the first 256-bit operand are copied to bits
1544 ///    from the second 256-bit operand are copied to bits [127:64] and bits
1546 ///    operand contain a value of 0xF, the 256-bit destination vector would
1558 ///    A 256-bit vector of [4 x double].
1560 ///    A 256-bit vector of [4 x double].
1562 ///    An immediate value containing 8-bit values specifying which elements to
1563 ///    copy from \a a and \a b: \n
1565 ///    destination. \n
1567 ///    destination. \n
1569 ///    destination. \n
1571 ///    destination. \n
1573 ///    destination. \n
1575 ///    destination. \n
1577 ///    destination. \n
1580 /// \returns A 256-bit vector of [4 x double] containing the shuffled values.
1586 #define _CMP_EQ_UQ    0x08 /* Equal (unordered, non-signaling)  */
1587 #define _CMP_NGE_US   0x09 /* Not-greater-than-or-equal (unordered, signaling)  */
1588 #define _CMP_NGT_US   0x0a /* Not-greater-than (unordered, signaling)  */
1589 #define _CMP_FALSE_OQ 0x0b /* False (ordered, non-signaling)  */
1590 #define _CMP_NEQ_OQ   0x0c /* Not-equal (ordered, non-signaling)  */
1591 #define _CMP_GE_OS    0x0d /* Greater-than-or-equal (ordered, signaling)  */
1592 #define _CMP_GT_OS    0x0e /* Greater-than (ordered, signaling)  */
1593 #define _CMP_TRUE_UQ  0x0f /* True (unordered, non-signaling)  */
1595 #define _CMP_LT_OQ    0x11 /* Less-than (ordered, non-signaling)  */
1596 #define _CMP_LE_OQ    0x12 /* Less-than-or-equal (ordered, non-signaling)  */
1598 #define _CMP_NEQ_US   0x14 /* Not-equal (unordered, signaling)  */
1599 #define _CMP_NLT_UQ   0x15 /* Not-less-than (unordered, non-signaling)  */
1600 #define _CMP_NLE_UQ   0x16 /* Not-less-than-or-equal (unordered, non-signaling)  */
1603 #define _CMP_NGE_UQ   0x19 /* Not-greater-than-or-equal (unordered, non-signaling)  */
1604 #define _CMP_NGT_UQ   0x1a /* Not-greater-than (unordered, non-signaling)  */
1606 #define _CMP_NEQ_OS   0x1c /* Not-equal (ordered, signaling)  */
1607 #define _CMP_GE_OQ    0x1d /* Greater-than-or-equal (ordered, non-signaling)  */
1608 #define _CMP_GT_OQ    0x1e /* Greater-than (ordered, non-signaling)  */
1612 /// Compares each of the corresponding double-precision values of two
1613 ///    128-bit vectors of [2 x double], using the operation specified by the
1614 ///    immediate integer operand.
1629 ///    A 128-bit vector of [2 x double].
1631 ///    A 128-bit vector of [2 x double].
1633 ///    An immediate integer operand, with bits [4:0] specifying which comparison
1634 ///    operation to use: \n
1635 ///    0x00: Equal (ordered, non-signaling) \n
1636 ///    0x01: Less-than (ordered, signaling) \n
1637 ///    0x02: Less-than-or-equal (ordered, signaling) \n
1638 ///    0x03: Unordered (non-signaling) \n
1639 ///    0x04: Not-equal (unordered, non-signaling) \n
1640 ///    0x05: Not-less-than (unordered, signaling) \n
1641 ///    0x06: Not-less-than-or-equal (unordered, signaling) \n
1642 ///    0x07: Ordered (non-signaling) \n
1643 ///    0x08: Equal (unordered, non-signaling) \n
1644 ///    0x09: Not-greater-than-or-equal (unordered, signaling) \n
1645 ///    0x0A: Not-greater-than (unordered, signaling) \n
1646 ///    0x0B: False (ordered, non-signaling) \n
1647 ///    0x0C: Not-equal (ordered, non-signaling) \n
1648 ///    0x0D: Greater-than-or-equal (ordered, signaling) \n
1649 ///    0x0E: Greater-than (ordered, signaling) \n
1650 ///    0x0F: True (unordered, non-signaling) \n
1651 ///    0x10: Equal (ordered, signaling) \n
1652 ///    0x11: Less-than (ordered, non-signaling) \n
1653 ///    0x12: Less-than-or-equal (ordered, non-signaling) \n
1654 ///    0x13: Unordered (signaling) \n
1655 ///    0x14: Not-equal (unordered, signaling) \n
1656 ///    0x15: Not-less-than (unordered, non-signaling) \n
1657 ///    0x16: Not-less-than-or-equal (unordered, non-signaling) \n
1658 ///    0x17: Ordered (signaling) \n
1659 ///    0x18: Equal (unordered, signaling) \n
1660 ///    0x19: Not-greater-than-or-equal (unordered, non-signaling) \n
1661 ///    0x1A: Not-greater-than (unordered, non-signaling) \n
1662 ///    0x1B: False (ordered, signaling) \n
1663 ///    0x1C: Not-equal (ordered, signaling) \n
1664 ///    0x1D: Greater-than-or-equal (ordered, non-signaling) \n
1665 ///    0x1E: Greater-than (ordered, non-signaling) \n
1667 /// \returns A 128-bit vector of [2 x double] containing the comparison results.
1671 /// Compares each of the corresponding values of two 128-bit vectors of
1672 ///    [4 x float], using the operation specified by the immediate integer
1688 ///    A 128-bit vector of [4 x float].
1690 ///    A 128-bit vector of [4 x float].
1692 ///    An immediate integer operand, with bits [4:0] specifying which comparison
1693 ///    operation to use: \n
1694 ///    0x00: Equal (ordered, non-signaling) \n
1695 ///    0x01: Less-than (ordered, signaling) \n
1696 ///    0x02: Less-than-or-equal (ordered, signaling) \n
1697 ///    0x03: Unordered (non-signaling) \n
1698 ///    0x04: Not-equal (unordered, non-signaling) \n
1699 ///    0x05: Not-less-than (unordered, signaling) \n
1700 ///    0x06: Not-less-than-or-equal (unordered, signaling) \n
1701 ///    0x07: Ordered (non-signaling) \n
1702 ///    0x08: Equal (unordered, non-signaling) \n
1703 ///    0x09: Not-greater-than-or-equal (unordered, signaling) \n
1704 ///    0x0A: Not-greater-than (unordered, signaling) \n
1705 ///    0x0B: False (ordered, non-signaling) \n
1706 ///    0x0C: Not-equal (ordered, non-signaling) \n
1707 ///    0x0D: Greater-than-or-equal (ordered, signaling) \n
1708 ///    0x0E: Greater-than (ordered, signaling) \n
1709 ///    0x0F: True (unordered, non-signaling) \n
1710 ///    0x10: Equal (ordered, signaling) \n
1711 ///    0x11: Less-than (ordered, non-signaling) \n
1712 ///    0x12: Less-than-or-equal (ordered, non-signaling) \n
1713 ///    0x13: Unordered (signaling) \n
1714 ///    0x14: Not-equal (unordered, signaling) \n
1715 ///    0x15: Not-less-than (unordered, non-signaling) \n
1716 ///    0x16: Not-less-than-or-equal (unordered, non-signaling) \n
1717 ///    0x17: Ordered (signaling) \n
1718 ///    0x18: Equal (unordered, signaling) \n
1719 ///    0x19: Not-greater-than-or-equal (unordered, non-signaling) \n
1720 ///    0x1A: Not-greater-than (unordered, non-signaling) \n
1721 ///    0x1B: False (ordered, signaling) \n
1722 ///    0x1C: Not-equal (ordered, signaling) \n
1723 ///    0x1D: Greater-than-or-equal (ordered, non-signaling) \n
1724 ///    0x1E: Greater-than (ordered, non-signaling) \n
1726 /// \returns A 128-bit vector of [4 x float] containing the comparison results.
1729 /// Compares each of the corresponding double-precision values of two
1730 ///    256-bit vectors of [4 x double], using the operation specified by the
1731 ///    immediate integer operand.
1746 ///    A 256-bit vector of [4 x double].
1748 ///    A 256-bit vector of [4 x double].
1750 ///    An immediate integer operand, with bits [4:0] specifying which comparison
1751 ///    operation to use: \n
1752 ///    0x00: Equal (ordered, non-signaling) \n
1753 ///    0x01: Less-than (ordered, signaling) \n
1754 ///    0x02: Less-than-or-equal (ordered, signaling) \n
1755 ///    0x03: Unordered (non-signaling) \n
1756 ///    0x04: Not-equal (unordered, non-signaling) \n
1757 ///    0x05: Not-less-than (unordered, signaling) \n
1758 ///    0x06: Not-less-than-or-equal (unordered, signaling) \n
1759 ///    0x07: Ordered (non-signaling) \n
1760 ///    0x08: Equal (unordered, non-signaling) \n
1761 ///    0x09: Not-greater-than-or-equal (unordered, signaling) \n
1762 ///    0x0A: Not-greater-than (unordered, signaling) \n
1763 ///    0x0B: False (ordered, non-signaling) \n
1764 ///    0x0C: Not-equal (ordered, non-signaling) \n
1765 ///    0x0D: Greater-than-or-equal (ordered, signaling) \n
1766 ///    0x0E: Greater-than (ordered, signaling) \n
1767 ///    0x0F: True (unordered, non-signaling) \n
1768 ///    0x10: Equal (ordered, signaling) \n
1769 ///    0x11: Less-than (ordered, non-signaling) \n
1770 ///    0x12: Less-than-or-equal (ordered, non-signaling) \n
1771 ///    0x13: Unordered (signaling) \n
1772 ///    0x14: Not-equal (unordered, signaling) \n
1773 ///    0x15: Not-less-than (unordered, non-signaling) \n
1774 ///    0x16: Not-less-than-or-equal (unordered, non-signaling) \n
1775 ///    0x17: Ordered (signaling) \n
1776 ///    0x18: Equal (unordered, signaling) \n
1777 ///    0x19: Not-greater-than-or-equal (unordered, non-signaling) \n
1778 ///    0x1A: Not-greater-than (unordered, non-signaling) \n
1779 ///    0x1B: False (ordered, signaling) \n
1780 ///    0x1C: Not-equal (ordered, signaling) \n
1781 ///    0x1D: Greater-than-or-equal (ordered, non-signaling) \n
1782 ///    0x1E: Greater-than (ordered, non-signaling) \n
1784 /// \returns A 256-bit vector of [4 x double] containing the comparison results.
1789 /// Compares each of the corresponding values of two 256-bit vectors of
1790 ///    [8 x float], using the operation specified by the immediate integer
1806 ///    A 256-bit vector of [8 x float].
1808 ///    A 256-bit vector of [8 x float].
1810 ///    An immediate integer operand, with bits [4:0] specifying which comparison
1811 ///    operation to use: \n
1812 ///    0x00: Equal (ordered, non-signaling) \n
1813 ///    0x01: Less-than (ordered, signaling) \n
1814 ///    0x02: Less-than-or-equal (ordered, signaling) \n
1815 ///    0x03: Unordered (non-signaling) \n
1816 ///    0x04: Not-equal (unordered, non-signaling) \n
1817 ///    0x05: Not-less-than (unordered, signaling) \n
1818 ///    0x06: Not-less-than-or-equal (unordered, signaling) \n
1819 ///    0x07: Ordered (non-signaling) \n
1820 ///    0x08: Equal (unordered, non-signaling) \n
1821 ///    0x09: Not-greater-than-or-equal (unordered, signaling) \n
1822 ///    0x0A: Not-greater-than (unordered, signaling) \n
1823 ///    0x0B: False (ordered, non-signaling) \n
1824 ///    0x0C: Not-equal (ordered, non-signaling) \n
1825 ///    0x0D: Greater-than-or-equal (ordered, signaling) \n
1826 ///    0x0E: Greater-than (ordered, signaling) \n
1827 ///    0x0F: True (unordered, non-signaling) \n
1828 ///    0x10: Equal (ordered, signaling) \n
1829 ///    0x11: Less-than (ordered, non-signaling) \n
1830 ///    0x12: Less-than-or-equal (ordered, non-signaling) \n
1831 ///    0x13: Unordered (signaling) \n
1832 ///    0x14: Not-equal (unordered, signaling) \n
1833 ///    0x15: Not-less-than (unordered, non-signaling) \n
1834 ///    0x16: Not-less-than-or-equal (unordered, non-signaling) \n
1835 ///    0x17: Ordered (signaling) \n
1836 ///    0x18: Equal (unordered, signaling) \n
1837 ///    0x19: Not-greater-than-or-equal (unordered, non-signaling) \n
1838 ///    0x1A: Not-greater-than (unordered, non-signaling) \n
1839 ///    0x1B: False (ordered, signaling) \n
1840 ///    0x1C: Not-equal (ordered, signaling) \n
1841 ///    0x1D: Greater-than-or-equal (ordered, non-signaling) \n
1842 ///    0x1E: Greater-than (ordered, non-signaling) \n
1844 /// \returns A 256-bit vector of [8 x float] containing the comparison results.
1850 /// Compares each of the corresponding scalar double-precision values of
1851 ///    two 128-bit vectors of [2 x double], using the operation specified by the
1852 ///    immediate integer operand.
1867 ///    A 128-bit vector of [2 x double].
1869 ///    A 128-bit vector of [2 x double].
1871 ///    An immediate integer operand, with bits [4:0] specifying which comparison
1872 ///    operation to use: \n
1873 ///    0x00: Equal (ordered, non-signaling) \n
1874 ///    0x01: Less-than (ordered, signaling) \n
1875 ///    0x02: Less-than-or-equal (ordered, signaling) \n
1876 ///    0x03: Unordered (non-signaling) \n
1877 ///    0x04: Not-equal (unordered, non-signaling) \n
1878 ///    0x05: Not-less-than (unordered, signaling) \n
1879 ///    0x06: Not-less-than-or-equal (unordered, signaling) \n
1880 ///    0x07: Ordered (non-signaling) \n
1881 ///    0x08: Equal (unordered, non-signaling) \n
1882 ///    0x09: Not-greater-than-or-equal (unordered, signaling) \n
1883 ///    0x0A: Not-greater-than (unordered, signaling) \n
1884 ///    0x0B: False (ordered, non-signaling) \n
1885 ///    0x0C: Not-equal (ordered, non-signaling) \n
1886 ///    0x0D: Greater-than-or-equal (ordered, signaling) \n
1887 ///    0x0E: Greater-than (ordered, signaling) \n
1888 ///    0x0F: True (unordered, non-signaling) \n
1889 ///    0x10: Equal (ordered, signaling) \n
1890 ///    0x11: Less-than (ordered, non-signaling) \n
1891 ///    0x12: Less-than-or-equal (ordered, non-signaling) \n
1892 ///    0x13: Unordered (signaling) \n
1893 ///    0x14: Not-equal (unordered, signaling) \n
1894 ///    0x15: Not-less-than (unordered, non-signaling) \n
1895 ///    0x16: Not-less-than-or-equal (unordered, non-signaling) \n
1896 ///    0x17: Ordered (signaling) \n
1897 ///    0x18: Equal (unordered, signaling) \n
1898 ///    0x19: Not-greater-than-or-equal (unordered, non-signaling) \n
1899 ///    0x1A: Not-greater-than (unordered, non-signaling) \n
1900 ///    0x1B: False (ordered, signaling) \n
1901 ///    0x1C: Not-equal (ordered, signaling) \n
1902 ///    0x1D: Greater-than-or-equal (ordered, non-signaling) \n
1903 ///    0x1E: Greater-than (ordered, non-signaling) \n
1905 /// \returns A 128-bit vector of [2 x double] containing the comparison results.
1909 /// Compares each of the corresponding scalar values of two 128-bit
1911 ///    integer operand.
1926 ///    A 128-bit vector of [4 x float].
1928 ///    A 128-bit vector of [4 x float].
1930 ///    An immediate integer operand, with bits [4:0] specifying which comparison
1931 ///    operation to use: \n
1932 ///    0x00: Equal (ordered, non-signaling) \n
1933 ///    0x01: Less-than (ordered, signaling) \n
1934 ///    0x02: Less-than-or-equal (ordered, signaling) \n
1935 ///    0x03: Unordered (non-signaling) \n
1936 ///    0x04: Not-equal (unordered, non-signaling) \n
1937 ///    0x05: Not-less-than (unordered, signaling) \n
1938 ///    0x06: Not-less-than-or-equal (unordered, signaling) \n
1939 ///    0x07: Ordered (non-signaling) \n
1940 ///    0x08: Equal (unordered, non-signaling) \n
1941 ///    0x09: Not-greater-than-or-equal (unordered, signaling) \n
1942 ///    0x0A: Not-greater-than (unordered, signaling) \n
1943 ///    0x0B: False (ordered, non-signaling) \n
1944 ///    0x0C: Not-equal (ordered, non-signaling) \n
1945 ///    0x0D: Greater-than-or-equal (ordered, signaling) \n
1946 ///    0x0E: Greater-than (ordered, signaling) \n
1947 ///    0x0F: True (unordered, non-signaling) \n
1948 ///    0x10: Equal (ordered, signaling) \n
1949 ///    0x11: Less-than (ordered, non-signaling) \n
1950 ///    0x12: Less-than-or-equal (ordered, non-signaling) \n
1951 ///    0x13: Unordered (signaling) \n
1952 ///    0x14: Not-equal (unordered, signaling) \n
1953 ///    0x15: Not-less-than (unordered, non-signaling) \n
1954 ///    0x16: Not-less-than-or-equal (unordered, non-signaling) \n
1955 ///    0x17: Ordered (signaling) \n
1956 ///    0x18: Equal (unordered, signaling) \n
1957 ///    0x19: Not-greater-than-or-equal (unordered, non-signaling) \n
1958 ///    0x1A: Not-greater-than (unordered, non-signaling) \n
1959 ///    0x1B: False (ordered, signaling) \n
1960 ///    0x1C: Not-equal (ordered, signaling) \n
1961 ///    0x1D: Greater-than-or-equal (ordered, non-signaling) \n
1962 ///    0x1E: Greater-than (ordered, non-signaling) \n
1964 /// \returns A 128-bit vector of [4 x float] containing the comparison results.
1973 /// int _mm256_extract_epi32(__m256i X, const int N);
1980 ///    A 256-bit vector of [8 x i32].
1981 /// \param N
1982 ///    An immediate integer operand with bits [2:0] determining which vector
1984 /// \returns A 32-bit integer containing the extracted 32 bits of extended
1986 #define _mm256_extract_epi32(X, N) \  argument
1987   ((int)__builtin_ia32_vec_ext_v8si((__v8si)(__m256i)(X), (int)(N)))
1995 /// int _mm256_extract_epi16(__m256i X, const int N);
2002 ///    A 256-bit integer vector of [16 x i16].
2003 /// \param N
2004 ///    An immediate integer operand with bits [3:0] determining which vector
2006 /// \returns A 32-bit integer containing the extracted 16 bits of zero extended
2008 #define _mm256_extract_epi16(X, N) \  argument
2010                                                      (int)(N)))
2018 /// int _mm256_extract_epi8(__m256i X, const int N);
2025 ///    A 256-bit integer vector of [32 x i8].
2026 /// \param N
2027 ///    An immediate integer operand with bits [4:0] determining which vector
2029 /// \returns A 32-bit integer containing the extracted 8 bits of zero extended
2031 #define _mm256_extract_epi8(X, N) \  argument
2033                                                     (int)(N)))
2042 /// long long _mm256_extract_epi64(__m256i X, const int N);
2049 ///    A 256-bit integer vector of [4 x i64].
2050 /// \param N
2051 ///    An immediate integer operand with bits [1:0] determining which vector
2053 /// \returns A 64-bit integer containing the extracted 64 bits of extended
2055 #define _mm256_extract_epi64(X, N) \  argument
2056   ((long long)__builtin_ia32_vec_ext_v4di((__v4di)(__m256i)(X), (int)(N)))
2066 /// __m256i _mm256_insert_epi32(__m256i X, int I, const int N);
2075 ///    An integer value. The replacement value for the insert operation.
2076 /// \param N
2077 ///    An immediate integer specifying the index of the vector element to be
2080 ///    \a N with \a I.
2081 #define _mm256_insert_epi32(X, I, N) \  argument
2083                                         (int)(I), (int)(N)))
2093 /// __m256i _mm256_insert_epi16(__m256i X, int I, const int N);
2102 ///    An i16 integer value. The replacement value for the insert operation.
2103 /// \param N
2104 ///    An immediate integer specifying the index of the vector element to be
2107 ///    \a N with \a I.
2108 #define _mm256_insert_epi16(X, I, N) \  argument
2110                                          (int)(I), (int)(N)))
2119 /// __m256i _mm256_insert_epi8(__m256i X, int I, const int N);
2128 ///    An i8 integer value. The replacement value for the insert operation.
2129 /// \param N
2130 ///    An immediate integer specifying the index of the vector element to be
2133 ///    \a N with \a I.
2134 #define _mm256_insert_epi8(X, I, N) \  argument
2136                                          (int)(I), (int)(N)))
2146 /// __m256i _mm256_insert_epi64(__m256i X, int I, const int N);
2155 ///    A 64-bit integer value. The replacement value for the insert operation.
2156 /// \param N
2157 ///    An immediate integer specifying the index of the vector element to be
2160 ///     \a N with \a I.
2161 #define _mm256_insert_epi64(X, I, N) \  argument
2163                                         (long long)(I), (int)(N)))
2174 ///    A 128-bit integer vector of [4 x i32].
2175 /// \returns A 256-bit vector of [4 x double] containing the converted values.
2189 ///    A 256-bit integer vector.
2190 /// \returns A 256-bit vector of [8 x float] containing the converted values.
2197 /// Converts a 256-bit vector of [4 x double] into a 128-bit vector of
2205 ///    A 256-bit vector of [4 x double].
2206 /// \returns A 128-bit vector of [4 x float] containing the converted values.
2215 ///    If a converted value does not fit in a 32-bit integer, raises a
2216 ///    floating-point invalid exception. If the exception is masked, returns
2217 ///    the most negative integer.
2224 ///    A 256-bit vector of [8 x float].
2225 /// \returns A 256-bit integer vector containing the converted values.
2232 /// Converts a 128-bit vector of [4 x float] into a 256-bit vector of [4
2240 ///    A 128-bit vector of [4 x float].
2241 /// \returns A 256-bit vector of [4 x double] containing the converted values.
2248 /// Converts a 256-bit vector of [4 x double] into four signed truncated
2249 ///    (rounded toward zero) 32-bit integers returned in a 128-bit vector of
2252 ///    If a converted value does not fit in a 32-bit integer, raises a
2253 ///    floating-point invalid exception. If the exception is masked, returns
2254 ///    the most negative integer.
2261 ///    A 256-bit vector of [4 x double].
2262 /// \returns A 128-bit integer vector containing the converted values.
2269 /// Converts a 256-bit vector of [4 x double] into a 128-bit vector of
2272 ///    If a converted value does not fit in a 32-bit integer, raises a
2273 ///    floating-point invalid exception. If the exception is masked, returns
2274 ///    the most negative integer.
2281 ///    A 256-bit vector of [4 x double].
2282 /// \returns A 128-bit integer vector containing the converted values.
2290 ///    toward zero) 32-bit integers returned in a vector of [8 x i32].
2292 ///    If a converted value does not fit in a 32-bit integer, raises a
2293 ///    floating-point invalid exception. If the exception is masked, returns
2294 ///    the most negative integer.
2301 ///    A 256-bit vector of [8 x float].
2302 /// \returns A 256-bit integer vector containing the converted values.
2317 ///    A 256-bit vector of [4 x double].
2333 ///    A 256-bit vector of [8 x i32].
2334 /// \returns A 32 bit integer containing the first element of the input vector.
2350 ///    A 256-bit vector of [8 x float].
2359 /// Moves and duplicates odd-indexed values from a 256-bit vector of
2360 ///    [8 x float] to float values in a 256-bit vector of [8 x float].
2367 ///    A 256-bit vector of [8 x float]. \n
2369 ///    the return value. \n
2371 ///    the return value. \n
2373 ///    return value. \n
2376 /// \returns A 256-bit vector of [8 x float] containing the moved and duplicated
2384 /// Moves and duplicates even-indexed values from a 256-bit vector of
2385 ///    [8 x float] to float values in a 256-bit vector of [8 x float].
2392 ///    A 256-bit vector of [8 x float]. \n
2394 ///    the return value. \n
2396 ///    the return value. \n
2398 ///    return value. \n
2401 /// \returns A 256-bit vector of [8 x float] containing the moved and duplicated
2409 /// Moves and duplicates double-precision floating point values from a
2410 ///    256-bit vector of [4 x double] to double-precision values in a 256-bit
2418 ///    A 256-bit vector of [4 x double]. \n
2420 ///    return value. \n
2423 /// \returns A 256-bit vector of [4 x double] containing the moved and
2432 /// Unpacks the odd-indexed vector elements from two 256-bit vectors of
2433 ///    [4 x double] and interleaves them into a 256-bit vector of [4 x double].
2440 ///    A 256-bit floating-point vector of [4 x double]. \n
2441 ///    Bits [127:64] are written to bits [63:0] of the return value. \n
2442 ///    Bits [255:192] are written to bits [191:128] of the return value. \n
2444 ///    A 256-bit floating-point vector of [4 x double]. \n
2445 ///    Bits [127:64] are written to bits [127:64] of the return value. \n
2446 ///    Bits [255:192] are written to bits [255:192] of the return value. \n
2447 /// \returns A 256-bit vector of [4 x double] containing the interleaved values.
2454 /// Unpacks the even-indexed vector elements from two 256-bit vectors of
2455 ///    [4 x double] and interleaves them into a 256-bit vector of [4 x double].
2462 ///    A 256-bit floating-point vector of [4 x double]. \n
2463 ///    Bits [63:0] are written to bits [63:0] of the return value. \n
2466 ///    A 256-bit floating-point vector of [4 x double]. \n
2467 ///    Bits [63:0] are written to bits [127:64] of the return value. \n
2468 ///    Bits [191:128] are written to bits [255:192] of the return value. \n
2469 /// \returns A 256-bit vector of [4 x double] containing the interleaved values.
2476 /// Unpacks the 32-bit vector elements 2, 3, 6 and 7 from each of the
2477 ///    two 256-bit vectors of [8 x float] and interleaves them into a 256-bit
2485 ///    A 256-bit vector of [8 x float]. \n
2486 ///    Bits [95:64] are written to bits [31:0] of the return value. \n
2487 ///    Bits [127:96] are written to bits [95:64] of the return value. \n
2488 ///    Bits [223:192] are written to bits [159:128] of the return value. \n
2491 ///    A 256-bit vector of [8 x float]. \n
2492 ///    Bits [95:64] are written to bits [63:32] of the return value. \n
2493 ///    Bits [127:96] are written to bits [127:96] of the return value. \n
2494 ///    Bits [223:192] are written to bits [191:160] of the return value. \n
2496 /// \returns A 256-bit vector of [8 x float] containing the interleaved values.
2503 /// Unpacks the 32-bit vector elements 0, 1, 4 and 5 from each of the
2504 ///    two 256-bit vectors of [8 x float] and interleaves them into a 256-bit
2512 ///    A 256-bit vector of [8 x float]. \n
2513 ///    Bits [31:0] are written to bits [31:0] of the return value. \n
2514 ///    Bits [63:32] are written to bits [95:64] of the return value. \n
2515 ///    Bits [159:128] are written to bits [159:128] of the return value. \n
2518 ///    A 256-bit vector of [8 x float]. \n
2519 ///    Bits [31:0] are written to bits [63:32] of the return value. \n
2520 ///    Bits [63:32] are written to bits [127:96] of the return value. \n
2521 ///    Bits [159:128] are written to bits [191:160] of the return value. \n
2523 /// \returns A 256-bit vector of [8 x float] containing the interleaved values.
2531 /// Given two 128-bit floating-point vectors of [2 x double], perform an
2532 ///    element-by-element comparison of the double-precision element in the
2536 ///    The EFLAGS register is updated as follows: \n
2537 ///    If there is at least one pair of double-precision elements where the
2538 ///    sign-bits of both elements are 1, the ZF flag is set to 0. Otherwise the
2539 ///    ZF flag is set to 1. \n
2540 ///    If there is at least one pair of double-precision elements where the
2541 ///    sign-bit of the first element is 0 and the sign-bit of the second element
2542 ///    is 1, the CF flag is set to 0. Otherwise the CF flag is set to 1. \n
2550 ///    A 128-bit vector of [2 x double].
2552 ///    A 128-bit vector of [2 x double].
2560 /// Given two 128-bit floating-point vectors of [2 x double], perform an
2561 ///    element-by-element comparison of the double-precision element in the
2565 ///    The EFLAGS register is updated as follows: \n
2566 ///    If there is at least one pair of double-precision elements where the
2567 ///    sign-bits of both elements are 1, the ZF flag is set to 0. Otherwise the
2568 ///    ZF flag is set to 1. \n
2569 ///    If there is at least one pair of double-precision elements where the
2570 ///    sign-bit of the first element is 0 and the sign-bit of the second element
2571 ///    is 1, the CF flag is set to 0. Otherwise the CF flag is set to 1. \n
2579 ///    A 128-bit vector of [2 x double].
2581 ///    A 128-bit vector of [2 x double].
2589 /// Given two 128-bit floating-point vectors of [2 x double], perform an
2590 ///    element-by-element comparison of the double-precision element in the
2594 ///    The EFLAGS register is updated as follows: \n
2595 ///    If there is at least one pair of double-precision elements where the
2596 ///    sign-bits of both elements are 1, the ZF flag is set to 0. Otherwise the
2597 ///    ZF flag is set to 1. \n
2598 ///    If there is at least one pair of double-precision elements where the
2599 ///    sign-bit of the first element is 0 and the sign-bit of the second element
2600 ///    is 1, the CF flag is set to 0. Otherwise the CF flag is set to 1. \n
2609 ///    A 128-bit vector of [2 x double].
2611 ///    A 128-bit vector of [2 x double].
2619 /// Given two 128-bit floating-point vectors of [4 x float], perform an
2620 ///    element-by-element comparison of the single-precision element in the
2624 ///    The EFLAGS register is updated as follows: \n
2625 ///    If there is at least one pair of single-precision elements where the
2626 ///    sign-bits of both elements are 1, the ZF flag is set to 0. Otherwise the
2627 ///    ZF flag is set to 1. \n
2628 ///    If there is at least one pair of single-precision elements where the
2629 ///    sign-bit of the first element is 0 and the sign-bit of the second element
2630 ///    is 1, the CF flag is set to 0. Otherwise the CF flag is set to 1. \n
2638 ///    A 128-bit vector of [4 x float].
2640 ///    A 128-bit vector of [4 x float].
2648 /// Given two 128-bit floating-point vectors of [4 x float], perform an
2649 ///    element-by-element comparison of the single-precision element in the
2653 ///    The EFLAGS register is updated as follows: \n
2654 ///    If there is at least one pair of single-precision elements where the
2655 ///    sign-bits of both elements are 1, the ZF flag is set to 0. Otherwise the
2656 ///    ZF flag is set to 1. \n
2657 ///    If there is at least one pair of single-precision elements where the
2658 ///    sign-bit of the first element is 0 and the sign-bit of the second element
2659 ///    is 1, the CF flag is set to 0. Otherwise the CF flag is set to 1. \n
2667 ///    A 128-bit vector of [4 x float].
2669 ///    A 128-bit vector of [4 x float].
2677 /// Given two 128-bit floating-point vectors of [4 x float], perform an
2678 ///    element-by-element comparison of the single-precision element in the
2682 ///    The EFLAGS register is updated as follows: \n
2683 ///    If there is at least one pair of single-precision elements where the
2684 ///    sign-bits of both elements are 1, the ZF flag is set to 0. Otherwise the
2685 ///    ZF flag is set to 1. \n
2686 ///    If there is at least one pair of single-precision elements where the
2687 ///    sign-bit of the first element is 0 and the sign-bit of the second element
2688 ///    is 1, the CF flag is set to 0. Otherwise the CF flag is set to 1. \n
2697 ///    A 128-bit vector of [4 x float].
2699 ///    A 128-bit vector of [4 x float].
2707 /// Given two 256-bit floating-point vectors of [4 x double], perform an
2708 ///    element-by-element comparison of the double-precision elements in the
2712 ///    The EFLAGS register is updated as follows: \n
2713 ///    If there is at least one pair of double-precision elements where the
2714 ///    sign-bits of both elements are 1, the ZF flag is set to 0. Otherwise the
2715 ///    ZF flag is set to 1. \n
2716 ///    If there is at least one pair of double-precision elements where the
2717 ///    sign-bit of the first element is 0 and the sign-bit of the second element
2718 ///    is 1, the CF flag is set to 0. Otherwise the CF flag is set to 1. \n
2726 ///    A 256-bit vector of [4 x double].
2728 ///    A 256-bit vector of [4 x double].
2736 /// Given two 256-bit floating-point vectors of [4 x double], perform an
2737 ///    element-by-element comparison of the double-precision elements in the
2741 ///    The EFLAGS register is updated as follows: \n
2742 ///    If there is at least one pair of double-precision elements where the
2743 ///    sign-bits of both elements are 1, the ZF flag is set to 0. Otherwise the
2744 ///    ZF flag is set to 1. \n
2745 ///    If there is at least one pair of double-precision elements where the
2746 ///    sign-bit of the first element is 0 and the sign-bit of the second element
2747 ///    is 1, the CF flag is set to 0. Otherwise the CF flag is set to 1. \n
2755 ///    A 256-bit vector of [4 x double].
2757 ///    A 256-bit vector of [4 x double].
2765 /// Given two 256-bit floating-point vectors of [4 x double], perform an
2766 ///    element-by-element comparison of the double-precision elements in the
2770 ///    The EFLAGS register is updated as follows: \n
2771 ///    If there is at least one pair of double-precision elements where the
2772 ///    sign-bits of both elements are 1, the ZF flag is set to 0. Otherwise the
2773 ///    ZF flag is set to 1. \n
2774 ///    If there is at least one pair of double-precision elements where the
2775 ///    sign-bit of the first element is 0 and the sign-bit of the second element
2776 ///    is 1, the CF flag is set to 0. Otherwise the CF flag is set to 1. \n
2785 ///    A 256-bit vector of [4 x double].
2787 ///    A 256-bit vector of [4 x double].
2795 /// Given two 256-bit floating-point vectors of [8 x float], perform an
2796 ///    element-by-element comparison of the single-precision element in the
2800 ///    The EFLAGS register is updated as follows: \n
2801 ///    If there is at least one pair of single-precision elements where the
2802 ///    sign-bits of both elements are 1, the ZF flag is set to 0. Otherwise the
2803 ///    ZF flag is set to 1. \n
2804 ///    If there is at least one pair of single-precision elements where the
2805 ///    sign-bit of the first element is 0 and the sign-bit of the second element
2806 ///    is 1, the CF flag is set to 0. Otherwise the CF flag is set to 1. \n
2814 ///    A 256-bit vector of [8 x float].
2816 ///    A 256-bit vector of [8 x float].
2824 /// Given two 256-bit floating-point vectors of [8 x float], perform an
2825 ///    element-by-element comparison of the single-precision element in the
2829 ///    The EFLAGS register is updated as follows: \n
2830 ///    If there is at least one pair of single-precision elements where the
2831 ///    sign-bits of both elements are 1, the ZF flag is set to 0. Otherwise the
2832 ///    ZF flag is set to 1. \n
2833 ///    If there is at least one pair of single-precision elements where the
2834 ///    sign-bit of the first element is 0 and the sign-bit of the second element
2835 ///    is 1, the CF flag is set to 0. Otherwise the CF flag is set to 1. \n
2843 ///    A 256-bit vector of [8 x float].
2845 ///    A 256-bit vector of [8 x float].
2853 /// Given two 256-bit floating-point vectors of [8 x float], perform an
2854 ///    element-by-element comparison of the single-precision elements in the
2858 ///    The EFLAGS register is updated as follows: \n
2859 ///    If there is at least one pair of single-precision elements where the
2860 ///    sign-bits of both elements are 1, the ZF flag is set to 0. Otherwise the
2861 ///    ZF flag is set to 1. \n
2862 ///    If there is at least one pair of single-precision elements where the
2863 ///    sign-bit of the first element is 0 and the sign-bit of the second element
2864 ///    is 1, the CF flag is set to 0. Otherwise the CF flag is set to 1. \n
2873 ///    A 256-bit vector of [8 x float].
2875 ///    A 256-bit vector of [8 x float].
2883 /// Given two 256-bit integer vectors, perform a bit-by-bit comparison
2886 ///    The EFLAGS register is updated as follows: \n
2888 ///    is set to 0. Otherwise the ZF flag is set to 1. \n
2891 ///    is set to 0. Otherwise the CF flag is set to 1. \n
2899 ///    A 256-bit integer vector.
2901 ///    A 256-bit integer vector.
2909 /// Given two 256-bit integer vectors, perform a bit-by-bit comparison
2912 ///    The EFLAGS register is updated as follows: \n
2914 ///    is set to 0. Otherwise the ZF flag is set to 1. \n
2917 ///    is set to 0. Otherwise the CF flag is set to 1. \n
2925 ///    A 256-bit integer vector.
2927 ///    A 256-bit integer vector.
2935 /// Given two 256-bit integer vectors, perform a bit-by-bit comparison
2938 ///    The EFLAGS register is updated as follows: \n
2940 ///    is set to 0. Otherwise the ZF flag is set to 1. \n
2943 ///    is set to 0. Otherwise the CF flag is set to 1. \n
2952 ///    A 256-bit integer vector.
2954 ///    A 256-bit integer vector.
2963 /// Extracts the sign bits of double-precision floating point elements
2964 ///    in a 256-bit vector of [4 x double] and writes them to the lower order
2972 ///    A 256-bit vector of [4 x double] containing the double-precision
2981 /// Extracts the sign bits of single-precision floating point elements
2982 ///    in a 256-bit vector of [8 x float] and writes them to the lower order
2990 ///    A 256-bit vector of [8 x float] containing the single-precision floating
3023 /// Loads a scalar single-precision floating point value from the
3032 ///    The single-precision floating point value to be broadcast.
3033 /// \returns A 128-bit vector of [4 x float] whose 32-bit elements are set
3041   float __f = ((const struct __mm_broadcast_ss_struct*)__a)->__f;  in _mm_broadcast_ss()
3045 /// Loads a scalar double-precision floating point value from the
3054 ///    The double-precision floating point value to be broadcast.
3055 /// \returns A 256-bit vector of [4 x double] whose 64-bit elements are set
3063   double __d = ((const struct __mm256_broadcast_sd_struct*)__a)->__d;  in _mm256_broadcast_sd()
3067 /// Loads a scalar single-precision floating point value from the
3076 ///    The single-precision floating point value to be broadcast.
3077 /// \returns A 256-bit vector of [8 x float] whose 32-bit elements are set
3085   float __f = ((const struct __mm256_broadcast_ss_struct*)__a)->__f;  in _mm256_broadcast_ss()
3089 /// Loads the data from a 128-bit vector of [2 x double] from the
3090 ///    specified address pointed to by \a __a and broadcasts it to 128-bit
3091 ///    elements in a 256-bit vector of [4 x double].
3098 ///    The 128-bit vector of [2 x double] to be broadcast.
3099 /// \returns A 256-bit vector of [4 x double] whose 128-bit elements are set
3109 /// Loads the data from a 128-bit vector of [4 x float] from the
3110 ///    specified address pointed to by \a __a and broadcasts it to 128-bit
3111 ///    elements in a 256-bit vector of [8 x float].
3118 ///    The 128-bit vector of [4 x float] to be broadcast.
3119 /// \returns A 256-bit vector of [8 x float] whose 128-bit elements are set
3130 /// Loads 4 double-precision floating point values from a 32-byte aligned
3138 ///    A 32-byte aligned pointer to a memory location containing
3139 ///    double-precision floating point values.
3140 /// \returns A 256-bit vector of [4 x double] containing the moved values.
3147 /// Loads 8 single-precision floating point values from a 32-byte aligned
3155 ///    A 32-byte aligned pointer to a memory location containing float values.
3156 /// \returns A 256-bit vector of [8 x float] containing the moved values.
3163 /// Loads 4 double-precision floating point values from an unaligned
3171 ///    A pointer to a memory location containing double-precision floating
3173 /// \returns A 256-bit vector of [4 x double] containing the moved values.
3180   return ((const struct __loadu_pd*)__p)->__v;  in _mm256_loadu_pd()
3183 /// Loads 8 single-precision floating point values from an unaligned
3191 ///    A pointer to a memory location containing single-precision floating
3193 /// \returns A 256-bit vector of [8 x float] containing the moved values.
3200   return ((const struct __loadu_ps*)__p)->__v;  in _mm256_loadu_ps()
3203 /// Loads 256 bits of integer data from a 32-byte aligned memory
3204 ///    location pointed to by \a __p into elements of a 256-bit integer vector.
3211 ///    A 32-byte aligned pointer to a 256-bit integer vector containing integer
3213 /// \returns A 256-bit integer vector containing the moved values.
3220 /// Loads 256 bits of integer data from an unaligned memory location
3221 ///    pointed to by \a __p into a 256-bit integer vector.
3228 ///    A pointer to a 256-bit integer vector containing integer values.
3229 /// \returns A 256-bit integer vector containing the moved values.
3236   return ((const struct __loadu_si256*)__p)->__v;  in _mm256_loadu_si256()
3239 /// Loads 256 bits of integer data from an unaligned memory location
3240 ///    pointed to by \a __p into a 256-bit integer vector. This intrinsic may
3249 ///    A pointer to a 256-bit integer vector containing integer values.
3250 /// \returns A 256-bit integer vector containing the moved values.
3258 /// Stores double-precision floating point values from a 256-bit vector
3259 ///    of [4 x double] to a 32-byte aligned memory location pointed to by
3267 ///    A 32-byte aligned pointer to a memory location that will receive the
3268 ///    double-precision floaing point values.
3270 ///    A 256-bit vector of [4 x double] containing the values to be moved.
3277 /// Stores single-precision floating point values from a 256-bit vector
3278 ///    of [8 x float] to a 32-byte aligned memory location pointed to by \a __p.
3285 ///    A 32-byte aligned pointer to a memory location that will receive the
3288 ///    A 256-bit vector of [8 x float] containing the values to be moved.
3295 /// Stores double-precision floating point values from a 256-bit vector
3303 ///    A pointer to a memory location that will receive the double-precision
3306 ///    A 256-bit vector of [4 x double] containing the values to be moved.
3313   ((struct __storeu_pd*)__p)->__v = __a;  in _mm256_storeu_pd()
3316 /// Stores single-precision floating point values from a 256-bit vector
3326 ///    A 256-bit vector of [8 x float] containing the values to be moved.
3333   ((struct __storeu_ps*)__p)->__v = __a;  in _mm256_storeu_ps()
3336 /// Stores integer values from a 256-bit integer vector to a 32-byte
3344 ///    A 32-byte aligned pointer to a memory location that will receive the
3345 ///    integer values.
3347 ///    A 256-bit integer vector containing the values to be moved.
3354 /// Stores integer values from a 256-bit integer vector to an unaligned
3362 ///    A pointer to a memory location that will receive the integer values.
3364 ///    A 256-bit integer vector containing the values to be moved.
3371   ((struct __storeu_si256*)__p)->__v = __a;  in _mm256_storeu_si256()
3375 /// Conditionally loads double-precision floating point elements from a
3376 ///    memory location pointed to by \a __p into a 128-bit vector of
3385 ///    A pointer to a memory location that contains the double-precision
3388 ///    A 128-bit integer vector containing the mask. The most significant bit of
3392 /// \returns A 128-bit vector of [2 x double] containing the loaded values.
3399 /// Conditionally loads double-precision floating point elements from a
3400 ///    memory location pointed to by \a __p into a 256-bit vector of
3409 ///    A pointer to a memory location that contains the double-precision
3412 ///    A 256-bit integer vector of [4 x quadword] containing the mask. The most
3416 /// \returns A 256-bit vector of [4 x double] containing the loaded values.
3424 /// Conditionally loads single-precision floating point elements from a
3425 ///    memory location pointed to by \a __p into a 128-bit vector of
3434 ///    A pointer to a memory location that contains the single-precision
3437 ///    A 128-bit integer vector containing the mask. The most significant bit of
3441 /// \returns A 128-bit vector of [4 x float] containing the loaded values.
3448 /// Conditionally loads single-precision floating point elements from a
3449 ///    memory location pointed to by \a __p into a 256-bit vector of
3458 ///    A pointer to a memory location that contains the single-precision
3461 ///    A 256-bit integer vector of [8 x dword] containing the mask. The most
3465 /// \returns A 256-bit vector of [8 x float] containing the loaded values.
3473 /// Moves single-precision floating point values from a 256-bit vector
3484 ///    A 256-bit integer vector of [8 x dword] containing the mask. The most
3490 ///    A 256-bit vector of [8 x float] containing the values to be stored.
3497 /// Moves double-precision values from a 128-bit vector of [2 x double]
3508 ///    A 128-bit integer vector containing the mask. The most significant bit of
3514 ///    A 128-bit vector of [2 x double] containing the values to be stored.
3521 /// Moves double-precision values from a 256-bit vector of [4 x double]
3532 ///    A 256-bit integer vector of [4 x quadword] containing the mask. The most
3538 ///    A 256-bit vector of [4 x double] containing the values to be stored.
3545 /// Moves single-precision floating point values from a 128-bit vector
3556 ///    A 128-bit integer vector containing the mask. The most significant bit of
3562 ///    A 128-bit vector of [4 x float] containing the values to be stored.
3570 /// Moves integer data from a 256-bit integer vector to a 32-byte
3572 ///    non-temporal (unlikely to be used again soon).
3579 ///    A pointer to a 32-byte aligned memory location that will receive the
3580 ///    integer values.
3582 ///    A 256-bit integer vector containing the values to be moved.
3590 /// Moves double-precision values from a 256-bit vector of [4 x double]
3591 ///    to a 32-byte aligned memory location. To minimize caching, the data is
3592 ///    flagged as non-temporal (unlikely to be used again soon).
3599 ///    A pointer to a 32-byte aligned memory location that will receive the
3600 ///    double-precision floating-point values.
3602 ///    A 256-bit vector of [4 x double] containing the values to be moved.
3610 /// Moves single-precision floating point values from a 256-bit vector
3611 ///    of [8 x float] to a 32-byte aligned memory location. To minimize
3612 ///    caching, the data is flagged as non-temporal (unlikely to be used again
3620 ///    A pointer to a 32-byte aligned memory location that will receive the
3621 ///    single-precision floating point values.
3623 ///    A 256-bit vector of [8 x float] containing the values to be moved.
3632 /// Create a 256-bit vector of [4 x double] with undefined values.
3638 /// \returns A 256-bit vector of [4 x double] containing undefined values.
3645 /// Create a 256-bit vector of [8 x float] with undefined values.
3651 /// \returns A 256-bit vector of [8 x float] containing undefined values.
3658 /// Create a 256-bit integer vector with undefined values.
3664 /// \returns A 256-bit integer vector containing undefined values.
3671 /// Constructs a 256-bit floating-point vector of [4 x double]
3672 ///    initialized with the specified double-precision floating-point values.
3680 ///    A double-precision floating-point value used to initialize bits [255:192]
3683 ///    A double-precision floating-point value used to initialize bits [191:128]
3686 ///    A double-precision floating-point value used to initialize bits [127:64]
3689 ///    A double-precision floating-point value used to initialize bits [63:0]
3691 /// \returns An initialized 256-bit floating-point vector of [4 x double].
3698 /// Constructs a 256-bit floating-point vector of [8 x float] initialized
3699 ///    with the specified single-precision floating-point values.
3707 ///    A single-precision floating-point value used to initialize bits [255:224]
3710 ///    A single-precision floating-point value used to initialize bits [223:192]
3713 ///    A single-precision floating-point value used to initialize bits [191:160]
3716 ///    A single-precision floating-point value used to initialize bits [159:128]
3719 ///    A single-precision floating-point value used to initialize bits [127:96]
3722 ///    A single-precision floating-point value used to initialize bits [95:64]
3725 ///    A single-precision floating-point value used to initialize bits [63:32]
3728 ///    A single-precision floating-point value used to initialize bits [31:0]
3730 /// \returns An initialized 256-bit floating-point vector of [8 x float].
3738 /// Constructs a 256-bit integer vector initialized with the specified
3739 ///    32-bit integral values.
3747 ///    A 32-bit integral value used to initialize bits [255:224] of the result.
3749 ///    A 32-bit integral value used to initialize bits [223:192] of the result.
3751 ///    A 32-bit integral value used to initialize bits [191:160] of the result.
3753 ///    A 32-bit integral value used to initialize bits [159:128] of the result.
3755 ///    A 32-bit integral value used to initialize bits [127:96] of the result.
3757 ///    A 32-bit integral value used to initialize bits [95:64] of the result.
3759 ///    A 32-bit integral value used to initialize bits [63:32] of the result.
3761 ///    A 32-bit integral value used to initialize bits [31:0] of the result.
3762 /// \returns An initialized 256-bit integer vector.
3770 /// Constructs a 256-bit integer vector initialized with the specified
3771 ///    16-bit integral values.
3779 ///    A 16-bit integral value used to initialize bits [255:240] of the result.
3781 ///    A 16-bit integral value used to initialize bits [239:224] of the result.
3783 ///    A 16-bit integral value used to initialize bits [223:208] of the result.
3785 ///    A 16-bit integral value used to initialize bits [207:192] of the result.
3787 ///    A 16-bit integral value used to initialize bits [191:176] of the result.
3789 ///    A 16-bit integral value used to initialize bits [175:160] of the result.
3791 ///    A 16-bit integral value used to initialize bits [159:144] of the result.
3793 ///    A 16-bit integral value used to initialize bits [143:128] of the result.
3795 ///    A 16-bit integral value used to initialize bits [127:112] of the result.
3797 ///    A 16-bit integral value used to initialize bits [111:96] of the result.
3799 ///    A 16-bit integral value used to initialize bits [95:80] of the result.
3801 ///    A 16-bit integral value used to initialize bits [79:64] of the result.
3803 ///    A 16-bit integral value used to initialize bits [63:48] of the result.
3805 ///    A 16-bit integral value used to initialize bits [47:32] of the result.
3807 ///    A 16-bit integral value used to initialize bits [31:16] of the result.
3809 ///    A 16-bit integral value used to initialize bits [15:0] of the result.
3810 /// \returns An initialized 256-bit integer vector.
3821 /// Constructs a 256-bit integer vector initialized with the specified
3822 ///    8-bit integral values.
3830 ///    An 8-bit integral value used to initialize bits [255:248] of the result.
3832 ///    An 8-bit integral value used to initialize bits [247:240] of the result.
3834 ///    An 8-bit integral value used to initialize bits [239:232] of the result.
3836 ///    An 8-bit integral value used to initialize bits [231:224] of the result.
3838 ///    An 8-bit integral value used to initialize bits [223:216] of the result.
3840 ///    An 8-bit integral value used to initialize bits [215:208] of the result.
3842 ///    An 8-bit integral value used to initialize bits [207:200] of the result.
3844 ///    An 8-bit integral value used to initialize bits [199:192] of the result.
3846 ///    An 8-bit integral value used to initialize bits [191:184] of the result.
3848 ///    An 8-bit integral value used to initialize bits [183:176] of the result.
3850 ///    An 8-bit integral value used to initialize bits [175:168] of the result.
3852 ///    An 8-bit integral value used to initialize bits [167:160] of the result.
3854 ///    An 8-bit integral value used to initialize bits [159:152] of the result.
3856 ///    An 8-bit integral value used to initialize bits [151:144] of the result.
3858 ///    An 8-bit integral value used to initialize bits [143:136] of the result.
3860 ///    An 8-bit integral value used to initialize bits [135:128] of the result.
3862 ///    An 8-bit integral value used to initialize bits [127:120] of the result.
3864 ///    An 8-bit integral value used to initialize bits [119:112] of the result.
3866 ///    An 8-bit integral value used to initialize bits [111:104] of the result.
3868 ///    An 8-bit integral value used to initialize bits [103:96] of the result.
3870 ///    An 8-bit integral value used to initialize bits [95:88] of the result.
3872 ///    An 8-bit integral value used to initialize bits [87:80] of the result.
3874 ///    An 8-bit integral value used to initialize bits [79:72] of the result.
3876 ///    An 8-bit integral value used to initialize bits [71:64] of the result.
3878 ///    An 8-bit integral value used to initialize bits [63:56] of the result.
3880 ///    An 8-bit integral value used to initialize bits [55:48] of the result.
3882 ///    An 8-bit integral value used to initialize bits [47:40] of the result.
3884 ///    An 8-bit integral value used to initialize bits [39:32] of the result.
3886 ///    An 8-bit integral value used to initialize bits [31:24] of the result.
3888 ///    An 8-bit integral value used to initialize bits [23:16] of the result.
3890 ///    An 8-bit integral value used to initialize bits [15:8] of the result.
3892 ///    An 8-bit integral value used to initialize bits [7:0] of the result.
3893 /// \returns An initialized 256-bit integer vector.
3912 /// Constructs a 256-bit integer vector initialized with the specified
3913 ///    64-bit integral values.
3921 ///    A 64-bit integral value used to initialize bits [255:192] of the result.
3923 ///    A 64-bit integral value used to initialize bits [191:128] of the result.
3925 ///    A 64-bit integral value used to initialize bits [127:64] of the result.
3927 ///    A 64-bit integral value used to initialize bits [63:0] of the result.
3928 /// \returns An initialized 256-bit integer vector.
3936 /// Constructs a 256-bit floating-point vector of [4 x double],
3937 ///    initialized in reverse order with the specified double-precision
3938 ///    floating-point values.
3946 ///    A double-precision floating-point value used to initialize bits [63:0]
3949 ///    A double-precision floating-point value used to initialize bits [127:64]
3952 ///    A double-precision floating-point value used to initialize bits [191:128]
3955 ///    A double-precision floating-point value used to initialize bits [255:192]
3957 /// \returns An initialized 256-bit floating-point vector of [4 x double].
3964 /// Constructs a 256-bit floating-point vector of [8 x float],
3965 ///    initialized in reverse order with the specified single-precision
3966 ///    float-point values.
3974 ///    A single-precision floating-point value used to initialize bits [31:0]
3977 ///    A single-precision floating-point value used to initialize bits [63:32]
3980 ///    A single-precision floating-point value used to initialize bits [95:64]
3983 ///    A single-precision floating-point value used to initialize bits [127:96]
3986 ///    A single-precision floating-point value used to initialize bits [159:128]
3989 ///    A single-precision floating-point value used to initialize bits [191:160]
3992 ///    A single-precision floating-point value used to initialize bits [223:192]
3995 ///    A single-precision floating-point value used to initialize bits [255:224]
3997 /// \returns An initialized 256-bit floating-point vector of [8 x float].
4005 /// Constructs a 256-bit integer vector, initialized in reverse order
4006 ///    with the specified 32-bit integral values.
4014 ///    A 32-bit integral value used to initialize bits [31:0] of the result.
4016 ///    A 32-bit integral value used to initialize bits [63:32] of the result.
4018 ///    A 32-bit integral value used to initialize bits [95:64] of the result.
4020 ///    A 32-bit integral value used to initialize bits [127:96] of the result.
4022 ///    A 32-bit integral value used to initialize bits [159:128] of the result.
4024 ///    A 32-bit integral value used to initialize bits [191:160] of the result.
4026 ///    A 32-bit integral value used to initialize bits [223:192] of the result.
4028 ///    A 32-bit integral value used to initialize bits [255:224] of the result.
4029 /// \returns An initialized 256-bit integer vector.
4037 /// Constructs a 256-bit integer vector, initialized in reverse order
4038 ///    with the specified 16-bit integral values.
4046 ///    A 16-bit integral value used to initialize bits [15:0] of the result.
4048 ///    A 16-bit integral value used to initialize bits [31:16] of the result.
4050 ///    A 16-bit integral value used to initialize bits [47:32] of the result.
4052 ///    A 16-bit integral value used to initialize bits [63:48] of the result.
4054 ///    A 16-bit integral value used to initialize bits [79:64] of the result.
4056 ///    A 16-bit integral value used to initialize bits [95:80] of the result.
4058 ///    A 16-bit integral value used to initialize bits [111:96] of the result.
4060 ///    A 16-bit integral value used to initialize bits [127:112] of the result.
4062 ///    A 16-bit integral value used to initialize bits [143:128] of the result.
4064 ///    A 16-bit integral value used to initialize bits [159:144] of the result.
4066 ///    A 16-bit integral value used to initialize bits [175:160] of the result.
4068 ///    A 16-bit integral value used to initialize bits [191:176] of the result.
4070 ///    A 16-bit integral value used to initialize bits [207:192] of the result.
4072 ///    A 16-bit integral value used to initialize bits [223:208] of the result.
4074 ///    A 16-bit integral value used to initialize bits [239:224] of the result.
4076 ///    A 16-bit integral value used to initialize bits [255:240] of the result.
4077 /// \returns An initialized 256-bit integer vector.
4090 /// Constructs a 256-bit integer vector, initialized in reverse order
4091 ///    with the specified 8-bit integral values.
4099 ///    An 8-bit integral value used to initialize bits [7:0] of the result.
4101 ///    An 8-bit integral value used to initialize bits [15:8] of the result.
4103 ///    An 8-bit integral value used to initialize bits [23:16] of the result.
4105 ///    An 8-bit integral value used to initialize bits [31:24] of the result.
4107 ///    An 8-bit integral value used to initialize bits [39:32] of the result.
4109 ///    An 8-bit integral value used to initialize bits [47:40] of the result.
4111 ///    An 8-bit integral value used to initialize bits [55:48] of the result.
4113 ///    An 8-bit integral value used to initialize bits [63:56] of the result.
4115 ///    An 8-bit integral value used to initialize bits [71:64] of the result.
4117 ///    An 8-bit integral value used to initialize bits [79:72] of the result.
4119 ///    An 8-bit integral value used to initialize bits [87:80] of the result.
4121 ///    An 8-bit integral value used to initialize bits [95:88] of the result.
4123 ///    An 8-bit integral value used to initialize bits [103:96] of the result.
4125 ///    An 8-bit integral value used to initialize bits [111:104] of the result.
4127 ///    An 8-bit integral value used to initialize bits [119:112] of the result.
4129 ///    An 8-bit integral value used to initialize bits [127:120] of the result.
4131 ///    An 8-bit integral value used to initialize bits [135:128] of the result.
4133 ///    An 8-bit integral value used to initialize bits [143:136] of the result.
4135 ///    An 8-bit integral value used to initialize bits [151:144] of the result.
4137 ///    An 8-bit integral value used to initialize bits [159:152] of the result.
4139 ///    An 8-bit integral value used to initialize bits [167:160] of the result.
4141 ///    An 8-bit integral value used to initialize bits [175:168] of the result.
4143 ///    An 8-bit integral value used to initialize bits [183:176] of the result.
4145 ///    An 8-bit integral value used to initialize bits [191:184] of the result.
4147 ///    An 8-bit integral value used to initialize bits [199:192] of the result.
4149 ///    An 8-bit integral value used to initialize bits [207:200] of the result.
4151 ///    An 8-bit integral value used to initialize bits [215:208] of the result.
4153 ///    An 8-bit integral value used to initialize bits [223:216] of the result.
4155 ///    An 8-bit integral value used to initialize bits [231:224] of the result.
4157 ///    An 8-bit integral value used to initialize bits [239:232] of the result.
4159 ///    An 8-bit integral value used to initialize bits [247:240] of the result.
4161 ///    An 8-bit integral value used to initialize bits [255:248] of the result.
4162 /// \returns An initialized 256-bit integer vector.
4179 /// Constructs a 256-bit integer vector, initialized in reverse order
4180 ///    with the specified 64-bit integral values.
4188 ///    A 64-bit integral value used to initialize bits [63:0] of the result.
4190 ///    A 64-bit integral value used to initialize bits [127:64] of the result.
4192 ///    A 64-bit integral value used to initialize bits [191:128] of the result.
4194 ///    A 64-bit integral value used to initialize bits [255:192] of the result.
4195 /// \returns An initialized 256-bit integer vector.
4203 /// Constructs a 256-bit floating-point vector of [4 x double], with each
4204 ///    of the four double-precision floating-point vector elements set to the
4205 ///    specified double-precision floating-point value.
4212 ///    A double-precision floating-point value used to initialize each vector
4214 /// \returns An initialized 256-bit floating-point vector of [4 x double].
4221 /// Constructs a 256-bit floating-point vector of [8 x float], with each
4222 ///    of the eight single-precision floating-point vector elements set to the
4223 ///    specified single-precision floating-point value.
4231 ///    A single-precision floating-point value used to initialize each vector
4233 /// \returns An initialized 256-bit floating-point vector of [8 x float].
4240 /// Constructs a 256-bit integer vector of [8 x i32], with each of the
4241 ///    32-bit integral vector elements set to the specified 32-bit integral
4250 ///    A 32-bit integral value used to initialize each vector element of the
4252 /// \returns An initialized 256-bit integer vector of [8 x i32].
4259 /// Constructs a 256-bit integer vector of [16 x i16], with each of the
4260 ///    16-bit integral vector elements set to the specified 16-bit integral
4268 ///    A 16-bit integral value used to initialize each vector element of the
4270 /// \returns An initialized 256-bit integer vector of [16 x i16].
4278 /// Constructs a 256-bit integer vector of [32 x i8], with each of the
4279 ///    8-bit integral vector elements set to the specified 8-bit integral value.
4286 ///    An 8-bit integral value used to initialize each vector element of the
4288 /// \returns An initialized 256-bit integer vector of [32 x i8].
4298 /// Constructs a 256-bit integer vector of [4 x i64], with each of the
4299 ///    64-bit integral vector elements set to the specified 64-bit integral
4307 ///    A 64-bit integral value used to initialize each vector element of the
4309 /// \returns An initialized 256-bit integer vector of [4 x i64].
4317 /// Constructs a 256-bit floating-point vector of [4 x double] with all
4324 /// \returns A 256-bit vector of [4 x double] with all elements set to zero.
4331 /// Constructs a 256-bit floating-point vector of [8 x float] with all
4338 /// \returns A 256-bit vector of [8 x float] with all elements set to zero.
4345 /// Constructs a 256-bit integer vector initialized to zero.
4351 /// \returns A 256-bit integer vector initialized to zero.
4359 /// Casts a 256-bit floating-point vector of [4 x double] into a 256-bit
4360 ///    floating-point vector of [8 x float].
4367 ///    A 256-bit floating-point vector of [4 x double].
4368 /// \returns A 256-bit floating-point vector of [8 x float] containing the same
4376 /// Casts a 256-bit floating-point vector of [4 x double] into a 256-bit
4377 ///    integer vector.
4384 ///    A 256-bit floating-point vector of [4 x double].
4385 /// \returns A 256-bit integer vector containing the same bitwise pattern as the
4393 /// Casts a 256-bit floating-point vector of [8 x float] into a 256-bit
4394 ///    floating-point vector of [4 x double].
4401 ///    A 256-bit floating-point vector of [8 x float].
4402 /// \returns A 256-bit floating-point vector of [4 x double] containing the same
4410 /// Casts a 256-bit floating-point vector of [8 x float] into a 256-bit
4411 ///    integer vector.
4418 ///    A 256-bit floating-point vector of [8 x float].
4419 /// \returns A 256-bit integer vector containing the same bitwise pattern as the
4427 /// Casts a 256-bit integer vector into a 256-bit floating-point vector
4435 ///    A 256-bit integer vector.
4436 /// \returns A 256-bit floating-point vector of [8 x float] containing the same
4444 /// Casts a 256-bit integer vector into a 256-bit floating-point vector
4452 ///    A 256-bit integer vector.
4453 /// \returns A 256-bit floating-point vector of [4 x double] containing the same
4461 /// Returns the lower 128 bits of a 256-bit floating-point vector of
4462 ///    [4 x double] as a 128-bit floating-point vector of [2 x double].
4469 ///    A 256-bit floating-point vector of [4 x double].
4470 /// \returns A 128-bit floating-point vector of [2 x double] containing the
4478 /// Returns the lower 128 bits of a 256-bit floating-point vector of
4479 ///    [8 x float] as a 128-bit floating-point vector of [4 x float].
4486 ///    A 256-bit floating-point vector of [8 x float].
4487 /// \returns A 128-bit floating-point vector of [4 x float] containing the
4495 /// Truncates a 256-bit integer vector into a 128-bit integer vector.
4502 ///    A 256-bit integer vector.
4503 /// \returns A 128-bit integer vector containing the lower 128 bits of the
4511 /// Constructs a 256-bit floating-point vector of [4 x double] from a
4512 ///    128-bit floating-point vector of [2 x double].
4522 ///    A 128-bit vector of [2 x double].
4523 /// \returns A 256-bit floating-point vector of [4 x double]. The lower 128 bits
4533 /// Constructs a 256-bit floating-point vector of [8 x float] from a
4534 ///    128-bit floating-point vector of [4 x float].
4544 ///    A 128-bit vector of [4 x float].
4545 /// \returns A 256-bit floating-point vector of [8 x float]. The lower 128 bits
4556 /// Constructs a 256-bit integer vector from a 128-bit integer vector.
4566 ///    A 128-bit integer vector.
4567 /// \returns A 256-bit integer vector. The lower 128 bits contain the value of
4576 /// Constructs a 256-bit floating-point vector of [4 x double] from a
4577 ///    128-bit floating-point vector of [2 x double]. The lower 128 bits
4586 ///    A 128-bit vector of [2 x double].
4587 /// \returns A 256-bit floating-point vector of [4 x double]. The lower 128 bits
4595 /// Constructs a 256-bit floating-point vector of [8 x float] from a
4596 ///    128-bit floating-point vector of [4 x float]. The lower 128 bits contain
4604 ///    A 128-bit vector of [4 x float].
4605 /// \returns A 256-bit floating-point vector of [8 x float]. The lower 128 bits
4613 /// Constructs a 256-bit integer vector from a 128-bit integer vector.
4622 ///    A 128-bit integer vector.
4623 /// \returns A 256-bit integer vector. The lower 128 bits contain the value of
4636 /// Constructs a new 256-bit vector of [8 x float] by first duplicating
4637 ///    a 256-bit vector of [8 x float] given in the first parameter, and then
4639 ///    128-bit vector of [4 x float] in the second parameter.
4641 ///    The immediate integer parameter determines between the upper or the lower
4653 ///    A 256-bit vector of [8 x float]. This vector is copied to the result
4657 ///    A 128-bit vector of [4 x float]. The contents of this parameter are
4661 ///    An immediate integer. The least significant bit determines how the values
4662 ///    from the two parameters are interleaved: \n
4665 ///    result. \n
4669 /// \returns A 256-bit vector of [8 x float] containing the interleaved values.
4674 /// Constructs a new 256-bit vector of [4 x double] by first duplicating
4675 ///    a 256-bit vector of [4 x double] given in the first parameter, and then
4677 ///    128-bit vector of [2 x double] in the second parameter.
4679 ///    The immediate integer parameter determines between the upper or the lower
4691 ///    A 256-bit vector of [4 x double]. This vector is copied to the result
4695 ///    A 128-bit vector of [2 x double]. The contents of this parameter are
4699 ///    An immediate integer. The least significant bit determines how the values
4700 ///    from the two parameters are interleaved: \n
4703 ///    result. \n
4707 /// \returns A 256-bit vector of [4 x double] containing the interleaved values.
4712 /// Constructs a new 256-bit integer vector by first duplicating a
4713 ///    256-bit integer vector given in the first parameter, and then replacing
4714 ///    either the upper or the lower 128 bits with the contents of a 128-bit
4715 ///    integer vector in the second parameter.
4717 ///    The immediate integer parameter determines between the upper or the lower
4729 ///    A 256-bit integer vector. This vector is copied to the result first, and
4733 ///    A 128-bit integer vector. The contents of this parameter are written to
4737 ///    An immediate integer. The least significant bit determines how the values
4738 ///    from the two parameters are interleaved: \n
4741 ///    result. \n
4745 /// \returns A 256-bit integer vector containing the interleaved values.
4755 /// Extracts either the upper or the lower 128 bits from a 256-bit vector
4756 ///    of [8 x float], as determined by the immediate integer parameter, and
4757 ///    returns the extracted bits as a 128-bit vector of [4 x float].
4768 ///    A 256-bit vector of [8 x float].
4770 ///    An immediate integer. The least significant bit determines which bits are
4771 ///    extracted from the first parameter: \n
4773 ///    result. \n
4775 /// \returns A 128-bit vector of [4 x float] containing the extracted bits.
4779 /// Extracts either the upper or the lower 128 bits from a 256-bit vector
4780 ///    of [4 x double], as determined by the immediate integer parameter, and
4781 ///    returns the extracted bits as a 128-bit vector of [2 x double].
4792 ///    A 256-bit vector of [4 x double].
4794 ///    An immediate integer. The least significant bit determines which bits are
4795 ///    extracted from the first parameter: \n
4797 ///    result. \n
4799 /// \returns A 128-bit vector of [2 x double] containing the extracted bits.
4803 /// Extracts either the upper or the lower 128 bits from a 256-bit
4804 ///    integer vector, as determined by the immediate integer parameter, and
4805 ///    returns the extracted bits as a 128-bit integer vector.
4816 ///    A 256-bit integer vector.
4818 ///    An immediate integer. The least significant bit determines which bits are
4819 ///    extracted from the first parameter:  \n
4821 ///    result. \n
4823 /// \returns A 128-bit integer vector containing the extracted bits.
4827 /// Constructs a 256-bit floating-point vector of [8 x float] by
4828 ///    concatenating two 128-bit floating-point vectors of [4 x float].
4835 ///    A 128-bit floating-point vector of [4 x float] to be copied to the upper
4838 ///    A 128-bit floating-point vector of [4 x float] to be copied to the lower
4840 /// \returns A 256-bit floating-point vector of [8 x float] containing the
4848 /// Constructs a 256-bit floating-point vector of [4 x double] by
4849 ///    concatenating two 128-bit floating-point vectors of [2 x double].
4856 ///    A 128-bit floating-point vector of [2 x double] to be copied to the upper
4859 ///    A 128-bit floating-point vector of [2 x double] to be copied to the lower
4861 /// \returns A 256-bit floating-point vector of [4 x double] containing the
4869 /// Constructs a 256-bit integer vector by concatenating two 128-bit
4870 ///    integer vectors.
4877 ///    A 128-bit integer vector to be copied to the upper 128 bits of the
4880 ///    A 128-bit integer vector to be copied to the lower 128 bits of the
4882 /// \returns A 256-bit integer vector containing the concatenated result.
4889 /// Constructs a 256-bit floating-point vector of [8 x float] by
4890 ///    concatenating two 128-bit floating-point vectors of [4 x float]. This is
4899 ///    A 128-bit floating-point vector of [4 x float] to be copied to the lower
4902 ///    A 128-bit floating-point vector of [4 x float] to be copied to the upper
4904 /// \returns A 256-bit floating-point vector of [8 x float] containing the
4912 /// Constructs a 256-bit floating-point vector of [4 x double] by
4913 ///    concatenating two 128-bit floating-point vectors of [2 x double]. This is
4922 ///    A 128-bit floating-point vector of [2 x double] to be copied to the lower
4925 ///    A 128-bit floating-point vector of [2 x double] to be copied to the upper
4927 /// \returns A 256-bit floating-point vector of [4 x double] containing the
4935 /// Constructs a 256-bit integer vector by concatenating two 128-bit
4936 ///    integer vectors. This is similar to _mm256_set_m128i, but the order of
4944 ///    A 128-bit integer vector to be copied to the lower 128 bits of the
4947 ///    A 128-bit integer vector to be copied to the upper 128 bits of the
4949 /// \returns A 256-bit integer vector containing the concatenated result.
4957 /// Loads two 128-bit floating-point vectors of [4 x float] from
4958 ///    unaligned memory locations and constructs a 256-bit floating-point vector
4959 ///    of [8 x float] by concatenating the two 128-bit vectors.
4967 ///    A pointer to a 128-bit memory location containing 4 consecutive
4968 ///    single-precision floating-point values. These values are to be copied to
4972 ///    A pointer to a 128-bit memory location containing 4 consecutive
4973 ///    single-precision floating-point values. These values are to be copied to
4976 /// \returns A 256-bit floating-point vector of [8 x float] containing the
4984 /// Loads two 128-bit floating-point vectors of [2 x double] from
4985 ///    unaligned memory locations and constructs a 256-bit floating-point vector
4986 ///    of [4 x double] by concatenating the two 128-bit vectors.
4994 ///    A pointer to a 128-bit memory location containing two consecutive
4995 ///    double-precision floating-point values. These values are to be copied to
4999 ///    A pointer to a 128-bit memory location containing two consecutive
5000 ///    double-precision floating-point values. These values are to be copied to
5003 /// \returns A 256-bit floating-point vector of [4 x double] containing the
5011 /// Loads two 128-bit integer vectors from unaligned memory locations and
5012 ///    constructs a 256-bit integer vector by concatenating the two 128-bit
5021 ///    A pointer to a 128-bit memory location containing a 128-bit integer
5025 ///    A pointer to a 128-bit memory location containing a 128-bit integer
5028 /// \returns A 256-bit integer vector containing the concatenated result.
5036 /// Stores the upper and lower 128 bits of a 256-bit floating-point
5045 ///    A pointer to a 128-bit memory location. Bits[255:128] of \a __a are to be
5049 ///    A pointer to a 128-bit memory location. Bits[127:0] of \a __a are to be
5053 ///    A 256-bit floating-point vector of [8 x float].
5065 /// Stores the upper and lower 128 bits of a 256-bit floating-point
5074 ///    A pointer to a 128-bit memory location. Bits[255:128] of \a __a are to be
5078 ///    A pointer to a 128-bit memory location. Bits[127:0] of \a __a are to be
5082 ///    A 256-bit floating-point vector of [4 x double].
5094 /// Stores the upper and lower 128 bits of a 256-bit integer vector into
5103 ///    A pointer to a 128-bit memory location. Bits[255:128] of \a __a are to be
5107 ///    A pointer to a 128-bit memory location. Bits[127:0] of \a __a are to be
5111 ///    A 256-bit integer vector.