vector_algorithms.cpp

// Copyright (c) Microsoft Corporation.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

#ifdef _M_CEE_PURE
#error _M_CEE_PURE should not be defined when compiling vector_algorithms.cpp.
#endif

#if defined(_M_IX86) || defined(_M_X64) // NB: includes _M_ARM64EC
#include<__msvc_minmax.hpp>
#include<cstdint>
#include<cstring>
#include<cwchar>
#include<xtr1common>

#ifndef _M_ARM64EC
#include<intrin.h>
#include<isa_availability.h>

extern"C"long __isa_enabled;

#ifndef _DEBUG
#pragma optimize("t", on) // Override /Os with /Ot for this TU
#endif// !defined(_DEBUG)

namespace {
bool_Use_avx2() noexcept {
return __isa_enabled & (1 << __ISA_AVAILABLE_AVX2);
 }

bool_Use_sse42() noexcept {
return __isa_enabled & (1 << __ISA_AVAILABLE_SSE42);
 }

struct [[nodiscard]] _Zeroupper_on_exit { // TRANSITION, DevCom-10331414
_Zeroupper_on_exit() = default;

_Zeroupper_on_exit(const _Zeroupper_on_exit&) = delete;
 _Zeroupper_on_exit& operator=(const _Zeroupper_on_exit&) = delete;

~_Zeroupper_on_exit() {
_mm256_zeroupper();
 }
 };

 __m256i _Avx2_tail_mask_32(constsize_t _Count_in_dwords) noexcept {
// _Count_in_dwords must be within [0, 8].
staticconstexprunsignedint _Tail_masks[16] = {
 ~0u, ~0u, ~0u, ~0u, ~0u, ~0u, ~0u, ~0u, 0, 0, 0, 0, 0, 0, 0, 0};
return_mm256_loadu_si256(reinterpret_cast<const __m256i*>(_Tail_masks + (8 - _Count_in_dwords)));
 }
} // namespace
#endif// !defined(_M_ARM64EC)

namespace {
template <class_BidIt>
void_Reverse_tail(_BidIt _First, _BidIt _Last) noexcept {
for (; _First != _Last && _First != --_Last; ++_First) {
constauto _Temp = *_First;
 *_First = *_Last;
 *_Last = _Temp;
 }
 }

template <class_BidIt, class_OutIt>
void_Reverse_copy_tail(_BidIt _First, _BidIt _Last, _OutIt _Dest) noexcept {
while (_First != _Last) {
 *_Dest++ = *--_Last;
 }
 }

size_t_Byte_length(constvoid* _First, constvoid* _Last) noexcept {
returnstatic_cast<constunsignedchar*>(_Last) - static_cast<constunsignedchar*>(_First);
 }

void_Rewind_bytes(void*& _Target, size_t _Offset) noexcept {
 _Target = static_cast<unsignedchar*>(_Target) - _Offset;
 }

void_Rewind_bytes(constvoid*& _Target, size_t _Offset) noexcept {
 _Target = static_cast<constunsignedchar*>(_Target) - _Offset;
 }

template <class_Integral>
void_Advance_bytes(void*& _Target, _Integral _Offset) noexcept {
 _Target = static_cast<unsignedchar*>(_Target) + _Offset;
 }

template <class_Integral>
void_Advance_bytes(constvoid*& _Target, _Integral _Offset) noexcept {
 _Target = static_cast<constunsignedchar*>(_Target) + _Offset;
 }
} // unnamed namespace

extern"C" {
__declspec(noalias) void __cdecl __std_swap_ranges_trivially_swappable_noalias(
void* _First1, void* _Last1, void* _First2) noexcept {
#ifndef _M_ARM64EC
constexprsize_t _Mask_32 = ~((static_cast<size_t>(1) << 5) - 1);
if (_Byte_length(_First1, _Last1) >= 32 && _Use_avx2()) {
constvoid* _Stop_at = _First1;
_Advance_bytes(_Stop_at, _Byte_length(_First1, _Last1) & _Mask_32);
do {
const __m256i _Left = _mm256_loadu_si256(static_cast<__m256i*>(_First1));
const __m256i _Right = _mm256_loadu_si256(static_cast<__m256i*>(_First2));
_mm256_storeu_si256(static_cast<__m256i*>(_First1), _Right);
_mm256_storeu_si256(static_cast<__m256i*>(_First2), _Left);
_Advance_bytes(_First1, 32);
_Advance_bytes(_First2, 32);
 } while (_First1 != _Stop_at);

_mm256_zeroupper(); // TRANSITION, DevCom-10331414
 }

constexprsize_t _Mask_16 = ~((static_cast<size_t>(1) << 4) - 1);
if (_Byte_length(_First1, _Last1) >= 16 && _Use_sse42()) {
constvoid* _Stop_at = _First1;
_Advance_bytes(_Stop_at, _Byte_length(_First1, _Last1) & _Mask_16);
do {
const __m128i _Left = _mm_loadu_si128(static_cast<__m128i*>(_First1));
const __m128i _Right = _mm_loadu_si128(static_cast<__m128i*>(_First2));
_mm_storeu_si128(static_cast<__m128i*>(_First1), _Right);
_mm_storeu_si128(static_cast<__m128i*>(_First2), _Left);
_Advance_bytes(_First1, 16);
_Advance_bytes(_First2, 16);
 } while (_First1 != _Stop_at);
 }

#if defined(_M_X64) // NOTE: UNALIGNED MEMORY ACCESSES
constexprsize_t _Mask_8 = ~((static_cast<size_t>(1) << 3) - 1);
if (_Byte_length(_First1, _Last1) >= 8) {
constvoid* _Stop_at = _First1;
_Advance_bytes(_Stop_at, _Byte_length(_First1, _Last1) & _Mask_8);
do {
constunsignedlonglong _Left = *static_cast<unsignedlonglong*>(_First1);
constunsignedlonglong _Right = *static_cast<unsignedlonglong*>(_First2);
 *static_cast<unsignedlonglong*>(_First1) = _Right;
 *static_cast<unsignedlonglong*>(_First2) = _Left;
_Advance_bytes(_First1, 8);
_Advance_bytes(_First2, 8);
 } while (_First1 != _Stop_at);
 }
#elif defined(_M_IX86) // NOTE: UNALIGNED MEMORY ACCESSES
constexprsize_t _Mask_4 = ~((static_cast<size_t>(1) << 2) - 1);
if (_Byte_length(_First1, _Last1) >= 4) {
constvoid* _Stop_at = _First1;
_Advance_bytes(_Stop_at, _Byte_length(_First1, _Last1) & _Mask_4);
do {
constunsignedlong _Left = *static_cast<unsignedlong*>(_First1);
constunsignedlong _Right = *static_cast<unsignedlong*>(_First2);
 *static_cast<unsignedlong*>(_First1) = _Right;
 *static_cast<unsignedlong*>(_First2) = _Left;
_Advance_bytes(_First1, 4);
_Advance_bytes(_First2, 4);
 } while (_First1 != _Stop_at);
 }
#else
#error Unsupported architecture
#endif
#endif// !_M_ARM64EC

auto _First1c = static_cast<unsignedchar*>(_First1);
auto _Last1c = static_cast<unsignedchar*>(_Last1);
auto _First2c = static_cast<unsignedchar*>(_First2);
for (; _First1c != _Last1c; ++_First1c, ++_First2c) {
unsignedchar _Ch = *_First1c;
 *_First1c = *_First2c;
 *_First2c = _Ch;
 }
}

// TRANSITION, ABI: __std_swap_ranges_trivially_swappable() is preserved for binary compatibility
void* __cdecl __std_swap_ranges_trivially_swappable(void* _First1, void* _Last1, void* _First2) noexcept {
__std_swap_ranges_trivially_swappable_noalias(_First1, _Last1, _First2);
returnstatic_cast<char*>(_First2) + (static_cast<char*>(_Last1) - static_cast<char*>(_First1));
}

__declspec(noalias) void __cdecl __std_reverse_trivially_swappable_1(void* _First, void* _Last) noexcept {
#ifndef _M_ARM64EC
if (_Byte_length(_First, _Last) >= 64 && _Use_avx2()) {
const __m256i _Reverse_char_lanes_avx = _mm256_set_epi8( //
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, //
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
constvoid* _Stop_at = _First;
_Advance_bytes(_Stop_at, (_Byte_length(_First, _Last) >> 1) & ~size_t{0x1F});
do {
_Advance_bytes(_Last, -32);
// vpermq to load left and right, and transpose the lanes
const __m256i _Left = _mm256_loadu_si256(static_cast<__m256i*>(_First));
const __m256i _Right = _mm256_loadu_si256(static_cast<__m256i*>(_Last));
const __m256i _Left_perm = _mm256_permute4x64_epi64(_Left, _MM_SHUFFLE(1, 0, 3, 2));
const __m256i _Right_perm = _mm256_permute4x64_epi64(_Right, _MM_SHUFFLE(1, 0, 3, 2));
// transpose all the chars in the lanes
const __m256i _Left_reversed = _mm256_shuffle_epi8(_Left_perm, _Reverse_char_lanes_avx);
const __m256i _Right_reversed = _mm256_shuffle_epi8(_Right_perm, _Reverse_char_lanes_avx);
_mm256_storeu_si256(static_cast<__m256i*>(_First), _Right_reversed);
_mm256_storeu_si256(static_cast<__m256i*>(_Last), _Left_reversed);
_Advance_bytes(_First, 32);
 } while (_First != _Stop_at);

_mm256_zeroupper(); // TRANSITION, DevCom-10331414
 }

if (_Byte_length(_First, _Last) >= 32 && _Use_sse42()) {
const __m128i _Reverse_char_sse = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
constvoid* _Stop_at = _First;
_Advance_bytes(_Stop_at, (_Byte_length(_First, _Last) >> 1) & ~size_t{0xF});
do {
_Advance_bytes(_Last, -16);
const __m128i _Left = _mm_loadu_si128(static_cast<__m128i*>(_First));
const __m128i _Right = _mm_loadu_si128(static_cast<__m128i*>(_Last));
const __m128i _Left_reversed = _mm_shuffle_epi8(_Left, _Reverse_char_sse);
const __m128i _Right_reversed = _mm_shuffle_epi8(_Right, _Reverse_char_sse);
_mm_storeu_si128(static_cast<__m128i*>(_First), _Right_reversed);
_mm_storeu_si128(static_cast<__m128i*>(_Last), _Left_reversed);
_Advance_bytes(_First, 16);
 } while (_First != _Stop_at);
 }
#endif// !_M_ARM64EC

_Reverse_tail(static_cast<unsignedchar*>(_First), static_cast<unsignedchar*>(_Last));
}

__declspec(noalias) void __cdecl __std_reverse_trivially_swappable_2(void* _First, void* _Last) noexcept {
#ifndef _M_ARM64EC
if (_Byte_length(_First, _Last) >= 64 && _Use_avx2()) {
const __m256i _Reverse_short_lanes_avx = _mm256_set_epi8( //
1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14, //
1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14);
constvoid* _Stop_at = _First;
_Advance_bytes(_Stop_at, (_Byte_length(_First, _Last) >> 1) & ~size_t{0x1F});
do {
_Advance_bytes(_Last, -32);
const __m256i _Left = _mm256_loadu_si256(static_cast<__m256i*>(_First));
const __m256i _Right = _mm256_loadu_si256(static_cast<__m256i*>(_Last));
const __m256i _Left_perm = _mm256_permute4x64_epi64(_Left, _MM_SHUFFLE(1, 0, 3, 2));
const __m256i _Right_perm = _mm256_permute4x64_epi64(_Right, _MM_SHUFFLE(1, 0, 3, 2));
const __m256i _Left_reversed = _mm256_shuffle_epi8(_Left_perm, _Reverse_short_lanes_avx);
const __m256i _Right_reversed = _mm256_shuffle_epi8(_Right_perm, _Reverse_short_lanes_avx);
_mm256_storeu_si256(static_cast<__m256i*>(_First), _Right_reversed);
_mm256_storeu_si256(static_cast<__m256i*>(_Last), _Left_reversed);
_Advance_bytes(_First, 32);
 } while (_First != _Stop_at);

_mm256_zeroupper(); // TRANSITION, DevCom-10331414
 }

if (_Byte_length(_First, _Last) >= 32 && _Use_sse42()) {
const __m128i _Reverse_short_sse = _mm_set_epi8(1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14);
constvoid* _Stop_at = _First;
_Advance_bytes(_Stop_at, (_Byte_length(_First, _Last) >> 1) & ~size_t{0xF});
do {
_Advance_bytes(_Last, -16);
const __m128i _Left = _mm_loadu_si128(static_cast<__m128i*>(_First));
const __m128i _Right = _mm_loadu_si128(static_cast<__m128i*>(_Last));
const __m128i _Left_reversed = _mm_shuffle_epi8(_Left, _Reverse_short_sse);
const __m128i _Right_reversed = _mm_shuffle_epi8(_Right, _Reverse_short_sse);
_mm_storeu_si128(static_cast<__m128i*>(_First), _Right_reversed);
_mm_storeu_si128(static_cast<__m128i*>(_Last), _Left_reversed);
_Advance_bytes(_First, 16);
 } while (_First != _Stop_at);
 }
#endif// !_M_ARM64EC

_Reverse_tail(static_cast<unsignedshort*>(_First), static_cast<unsignedshort*>(_Last));
}

__declspec(noalias) void __cdecl __std_reverse_trivially_swappable_4(void* _First, void* _Last) noexcept {
#ifndef _M_ARM64EC
if (_Byte_length(_First, _Last) >= 64 && _Use_avx2()) {
constvoid* _Stop_at = _First;
_Advance_bytes(_Stop_at, (_Byte_length(_First, _Last) >> 1) & ~size_t{0x1F});
const __m256i _Shuf = _mm256_set_epi32(0, 1, 2, 3, 4, 5, 6, 7);
do {
_Advance_bytes(_Last, -32);
const __m256i _Left = _mm256_loadu_si256(static_cast<__m256i*>(_First));
const __m256i _Right = _mm256_loadu_si256(static_cast<__m256i*>(_Last));
const __m256i _Left_reversed = _mm256_permutevar8x32_epi32(_Left, _Shuf);
const __m256i _Right_reversed = _mm256_permutevar8x32_epi32(_Right, _Shuf);
_mm256_storeu_si256(static_cast<__m256i*>(_First), _Right_reversed);
_mm256_storeu_si256(static_cast<__m256i*>(_Last), _Left_reversed);
_Advance_bytes(_First, 32);
 } while (_First != _Stop_at);

_mm256_zeroupper(); // TRANSITION, DevCom-10331414
 }

if (_Byte_length(_First, _Last) >= 32 && _Use_sse42()) {
constvoid* _Stop_at = _First;
_Advance_bytes(_Stop_at, (_Byte_length(_First, _Last) >> 1) & ~size_t{0xF});
do {
_Advance_bytes(_Last, -16);
const __m128i _Left = _mm_loadu_si128(static_cast<__m128i*>(_First));
const __m128i _Right = _mm_loadu_si128(static_cast<__m128i*>(_Last));
const __m128i _Left_reversed = _mm_shuffle_epi32(_Left, _MM_SHUFFLE(0, 1, 2, 3));
const __m128i _Right_reversed = _mm_shuffle_epi32(_Right, _MM_SHUFFLE(0, 1, 2, 3));
_mm_storeu_si128(static_cast<__m128i*>(_First), _Right_reversed);
_mm_storeu_si128(static_cast<__m128i*>(_Last), _Left_reversed);
_Advance_bytes(_First, 16);
 } while (_First != _Stop_at);
 }
#endif// !_M_ARM64EC

_Reverse_tail(static_cast<unsignedlong*>(_First), static_cast<unsignedlong*>(_Last));
}

__declspec(noalias) void __cdecl __std_reverse_trivially_swappable_8(void* _First, void* _Last) noexcept {
#ifndef _M_ARM64EC
if (_Byte_length(_First, _Last) >= 64 && _Use_avx2()) {
constvoid* _Stop_at = _First;
_Advance_bytes(_Stop_at, (_Byte_length(_First, _Last) >> 1) & ~size_t{0x1F});
do {
_Advance_bytes(_Last, -32);
const __m256i _Left = _mm256_loadu_si256(static_cast<__m256i*>(_First));
const __m256i _Right = _mm256_loadu_si256(static_cast<__m256i*>(_Last));
const __m256i _Left_reversed = _mm256_permute4x64_epi64(_Left, _MM_SHUFFLE(0, 1, 2, 3));
const __m256i _Right_reversed = _mm256_permute4x64_epi64(_Right, _MM_SHUFFLE(0, 1, 2, 3));
_mm256_storeu_si256(static_cast<__m256i*>(_First), _Right_reversed);
_mm256_storeu_si256(static_cast<__m256i*>(_Last), _Left_reversed);
_Advance_bytes(_First, 32);
 } while (_First != _Stop_at);

_mm256_zeroupper(); // TRANSITION, DevCom-10331414
 }

if (_Byte_length(_First, _Last) >= 32 && _Use_sse42()) {
constvoid* _Stop_at = _First;
_Advance_bytes(_Stop_at, (_Byte_length(_First, _Last) >> 1) & ~size_t{0xF});
do {
_Advance_bytes(_Last, -16);
const __m128i _Left = _mm_loadu_si128(static_cast<__m128i*>(_First));
const __m128i _Right = _mm_loadu_si128(static_cast<__m128i*>(_Last));
const __m128i _Left_reversed = _mm_shuffle_epi32(_Left, _MM_SHUFFLE(1, 0, 3, 2));
const __m128i _Right_reversed = _mm_shuffle_epi32(_Right, _MM_SHUFFLE(1, 0, 3, 2));
_mm_storeu_si128(static_cast<__m128i*>(_First), _Right_reversed);
_mm_storeu_si128(static_cast<__m128i*>(_Last), _Left_reversed);
_Advance_bytes(_First, 16);
 } while (_First != _Stop_at);
 }
#endif// !_M_ARM64EC

_Reverse_tail(static_cast<unsignedlonglong*>(_First), static_cast<unsignedlonglong*>(_Last));
}

__declspec(noalias) void __cdecl __std_reverse_copy_trivially_copyable_1(
constvoid* _First, constvoid* _Last, void* _Dest) noexcept {
#ifndef _M_ARM64EC
if (_Byte_length(_First, _Last) >= 32 && _Use_avx2()) {
const __m256i _Reverse_char_lanes_avx = _mm256_set_epi8( //
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, //
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
constvoid* _Stop_at = _Dest;
_Advance_bytes(_Stop_at, _Byte_length(_First, _Last) & ~size_t{0x1F});
do {
_Advance_bytes(_Last, -32);
const __m256i _Block = _mm256_loadu_si256(static_cast<const __m256i*>(_Last));
const __m256i _Block_permuted = _mm256_permute4x64_epi64(_Block, _MM_SHUFFLE(1, 0, 3, 2));
const __m256i _Block_reversed = _mm256_shuffle_epi8(_Block_permuted, _Reverse_char_lanes_avx);
_mm256_storeu_si256(static_cast<__m256i*>(_Dest), _Block_reversed);
_Advance_bytes(_Dest, 32);
 } while (_Dest != _Stop_at);

_mm256_zeroupper(); // TRANSITION, DevCom-10331414
 }

if (_Byte_length(_First, _Last) >= 16 && _Use_sse42()) {
const __m128i _Reverse_char_sse = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
constvoid* _Stop_at = _Dest;
_Advance_bytes(_Stop_at, _Byte_length(_First, _Last) & ~size_t{0xF});
do {
_Advance_bytes(_Last, -16);
const __m128i _Block = _mm_loadu_si128(static_cast<const __m128i*>(_Last));
const __m128i _Block_reversed = _mm_shuffle_epi8(_Block, _Reverse_char_sse);
_mm_storeu_si128(static_cast<__m128i*>(_Dest), _Block_reversed);
_Advance_bytes(_Dest, 16);
 } while (_Dest != _Stop_at);
 }
#endif// !_M_ARM64EC

_Reverse_copy_tail(static_cast<constunsignedchar*>(_First), static_cast<constunsignedchar*>(_Last),
static_cast<unsignedchar*>(_Dest));
}

__declspec(noalias) void __cdecl __std_reverse_copy_trivially_copyable_2(
constvoid* _First, constvoid* _Last, void* _Dest) noexcept {
#ifndef _M_ARM64EC
if (_Byte_length(_First, _Last) >= 32 && _Use_avx2()) {
const __m256i _Reverse_short_lanes_avx = _mm256_set_epi8( //
1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14, //
1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14);
constvoid* _Stop_at = _Dest;
_Advance_bytes(_Stop_at, _Byte_length(_First, _Last) & ~size_t{0x1F});
do {
_Advance_bytes(_Last, -32);
const __m256i _Block = _mm256_loadu_si256(static_cast<const __m256i*>(_Last));
const __m256i _Block_permuted = _mm256_permute4x64_epi64(_Block, _MM_SHUFFLE(1, 0, 3, 2));
const __m256i _Block_reversed = _mm256_shuffle_epi8(_Block_permuted, _Reverse_short_lanes_avx);
_mm256_storeu_si256(static_cast<__m256i*>(_Dest), _Block_reversed);
_Advance_bytes(_Dest, 32);
 } while (_Dest != _Stop_at);

_mm256_zeroupper(); // TRANSITION, DevCom-10331414
 }

if (_Byte_length(_First, _Last) >= 16 && _Use_sse42()) {
const __m128i _Reverse_short_sse = _mm_set_epi8(1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14);
constvoid* _Stop_at = _Dest;
_Advance_bytes(_Stop_at, _Byte_length(_First, _Last) & ~size_t{0xF});
do {
_Advance_bytes(_Last, -16);
const __m128i _Block = _mm_loadu_si128(static_cast<const __m128i*>(_Last));
const __m128i _Block_reversed = _mm_shuffle_epi8(_Block, _Reverse_short_sse);
_mm_storeu_si128(static_cast<__m128i*>(_Dest), _Block_reversed);
_Advance_bytes(_Dest, 16);
 } while (_Dest != _Stop_at);
 }
#endif// !_M_ARM64EC

_Reverse_copy_tail(static_cast<constunsignedshort*>(_First), static_cast<constunsignedshort*>(_Last),
static_cast<unsignedshort*>(_Dest));
}

__declspec(noalias) void __cdecl __std_reverse_copy_trivially_copyable_4(
constvoid* _First, constvoid* _Last, void* _Dest) noexcept {
#ifndef _M_ARM64EC
if (_Byte_length(_First, _Last) >= 32 && _Use_avx2()) {
constvoid* _Stop_at = _Dest;
_Advance_bytes(_Stop_at, _Byte_length(_First, _Last) & ~size_t{0x1F});
const __m256i _Shuf = _mm256_set_epi32(0, 1, 2, 3, 4, 5, 6, 7);
do {
_Advance_bytes(_Last, -32);
const __m256i _Block = _mm256_loadu_si256(static_cast<const __m256i*>(_Last));
const __m256i _Block_reversed = _mm256_permutevar8x32_epi32(_Block, _Shuf);
_mm256_storeu_si256(static_cast<__m256i*>(_Dest), _Block_reversed);
_Advance_bytes(_Dest, 32);
 } while (_Dest != _Stop_at);

_mm256_zeroupper(); // TRANSITION, DevCom-10331414
 }

if (_Byte_length(_First, _Last) >= 16 && _Use_sse42()) {
constvoid* _Stop_at = _Dest;
_Advance_bytes(_Stop_at, _Byte_length(_First, _Last) & ~size_t{0xF});
do {
_Advance_bytes(_Last, -16);
const __m128i _Block = _mm_loadu_si128(static_cast<const __m128i*>(_Last));
const __m128i _Block_reversed = _mm_shuffle_epi32(_Block, _MM_SHUFFLE(0, 1, 2, 3));
_mm_storeu_si128(static_cast<__m128i*>(_Dest), _Block_reversed);
_Advance_bytes(_Dest, 16);
 } while (_Dest != _Stop_at);
 }
#endif// !_M_ARM64EC

_Reverse_copy_tail(static_cast<constunsignedlong*>(_First), static_cast<constunsignedlong*>(_Last),
static_cast<unsignedlong*>(_Dest));
}

__declspec(noalias) void __cdecl __std_reverse_copy_trivially_copyable_8(
constvoid* _First, constvoid* _Last, void* _Dest) noexcept {
#ifndef _M_ARM64EC
if (_Byte_length(_First, _Last) >= 32 && _Use_avx2()) {
constvoid* _Stop_at = _Dest;
_Advance_bytes(_Stop_at, _Byte_length(_First, _Last) & ~size_t{0x1F});
do {
_Advance_bytes(_Last, -32);
const __m256i _Block = _mm256_loadu_si256(static_cast<const __m256i*>(_Last));
const __m256i _Block_reversed = _mm256_permute4x64_epi64(_Block, _MM_SHUFFLE(0, 1, 2, 3));
_mm256_storeu_si256(static_cast<__m256i*>(_Dest), _Block_reversed);
_Advance_bytes(_Dest, 32);
 } while (_Dest != _Stop_at);

_mm256_zeroupper(); // TRANSITION, DevCom-10331414
 }

if (_Byte_length(_First, _Last) >= 16 && _Use_sse42()) {
constvoid* _Stop_at = _Dest;
_Advance_bytes(_Stop_at, _Byte_length(_First, _Last) & ~size_t{0xF});
do {
_Advance_bytes(_Last, -16);
const __m128i _Block = _mm_loadu_si128(static_cast<const __m128i*>(_Last));
const __m128i _Block_reversed = _mm_shuffle_epi32(_Block, _MM_SHUFFLE(1, 0, 3, 2));
_mm_storeu_si128(static_cast<__m128i*>(_Dest), _Block_reversed);
_Advance_bytes(_Dest, 16);
 } while (_Dest != _Stop_at);
 }
#endif// !_M_ARM64EC

_Reverse_copy_tail(static_cast<constunsignedlonglong*>(_First), static_cast<constunsignedlonglong*>(_Last),
static_cast<unsignedlonglong*>(_Dest));
}

} // extern "C"

namespace {
template <class_Ty>
constvoid* _Min_tail(constvoid* const _First, constvoid* const _Last, constvoid* _Res, _Ty _Cur) noexcept {
for (auto _Ptr = static_cast<const _Ty*>(_First); _Ptr != _Last; ++_Ptr) {
if (*_Ptr < _Cur) {
 _Res = _Ptr;
 _Cur = *_Ptr;
 }
 }

return _Res;
 }

template <class_Ty>
constvoid* _Max_tail(constvoid* const _First, constvoid* const _Last, constvoid* _Res, _Ty _Cur) noexcept {
for (auto _Ptr = static_cast<const _Ty*>(_First); _Ptr != _Last; ++_Ptr) {
if (_Cur < *_Ptr) {
 _Res = _Ptr;
 _Cur = *_Ptr;
 }
 }

return _Res;
 }

template <class_Ty>
 _Min_max_element_t _Both_tail(constvoid* const _First, constvoid* const _Last, _Min_max_element_t& _Res,
 _Ty _Cur_min, _Ty _Cur_max) noexcept {
for (auto _Ptr = static_cast<const _Ty*>(_First); _Ptr != _Last; ++_Ptr) {
if (*_Ptr < _Cur_min) {
 _Res._Min = _Ptr;
 _Cur_min = *_Ptr;
 }
// Not else!
// * Needed for correctness if start with maximum, as we don't handle specially the first element.
// * Promote branchless code generation.
if (_Cur_max <= *_Ptr) {
 _Res._Max = _Ptr;
 _Cur_max = *_Ptr;
 }
 }

return _Res;
 }

enum _Min_max_mode {
 _Mode_min = 1 << 0,
 _Mode_max = 1 << 1,
 _Mode_both = _Mode_min | _Mode_max,
 };

template <class_Base>
struct_Minmax_traits_scalar : _Base {
staticconstexprbool _Vectorized = false;
staticconstexprsize_t _Tail_mask = 0;
 };

#ifndef _M_ARM64EC
struct_Minmax_traits_sse_base {
staticconstexprbool _Vectorized = true;
staticconstexprsize_t _Vec_size = 16;
staticconstexprsize_t _Vec_mask = 0xF;
staticconstexprsize_t _Tail_mask = 0;

static __m128i _Zero() noexcept {
return_mm_setzero_si128();
 }

static __m128i _All_ones() noexcept {
return_mm_set1_epi8(static_cast<char>(0xFF));
 }

static __m128i _Blend(const __m128i _Px1, const __m128i _Px2, const __m128i _Msk) noexcept {
return_mm_blendv_epi8(_Px1, _Px2, _Msk);
 }

staticunsignedlong_Mask(const __m128i _Val) noexcept {
return_mm_movemask_epi8(_Val);
 }

staticvoid_Exit_vectorized() noexcept {}
 };

struct_Minmax_traits_avx_base {
staticconstexprbool _Vectorized = true;
staticconstexprsize_t _Vec_size = 32;
staticconstexprsize_t _Vec_mask = 0x1F;

static __m256i _Zero() noexcept {
return_mm256_setzero_si256();
 }

static __m256i _All_ones() noexcept {
return_mm256_set1_epi8(static_cast<char>(0xFF));
 }

static __m256i _Blend(const __m256i _Px1, const __m256i _Px2, const __m256i _Msk) noexcept {
return_mm256_blendv_epi8(_Px1, _Px2, _Msk);
 }

staticunsignedlong_Mask(const __m256i _Val) noexcept {
return_mm256_movemask_epi8(_Val);
 }

staticvoid_Exit_vectorized() noexcept {
_mm256_zeroupper();
 }
 };

struct_Minmax_traits_avx_i_base : _Minmax_traits_avx_base {
staticconstexprsize_t _Tail_mask = 0x1C;

static __m256i _Blendval(const __m256i _Px1, const __m256i _Px2, const __m256i _Msk) noexcept {
return_mm256_blendv_epi8(_Px1, _Px2, _Msk);
 }

static __m256i _Load_mask(constvoid* _Src, const __m256i _Mask) noexcept {
return_mm256_maskload_epi32(reinterpret_cast<constint*>(_Src), _Mask);
 }
 };
#endif// !defined(_M_ARM64EC)

struct_Minmax_traits_1_base {
staticconstexprbool _Is_floating = false;

using _Signed_t = int8_t;
using _Unsigned_t = uint8_t;

staticconstexpr _Signed_t _Init_min_val = static_cast<_Signed_t>(0x7F);
staticconstexpr _Signed_t _Init_max_val = static_cast<_Signed_t>(0x80);

using _Minmax_i_t = _Min_max_1i;
using _Minmax_u_t = _Min_max_1u;

#ifndef _M_ARM64EC
staticconstexprbool _Has_portion_max = true;
staticconstexprsize_t _Portion_max = 256;
#endif// !defined(_M_ARM64EC)
 };

#ifndef _M_ARM64EC
struct_Minmax_traits_1_sse : _Minmax_traits_1_base, _Minmax_traits_sse_base {
static __m128i _Load(constvoid* _Src) noexcept {
return_mm_loadu_si128(reinterpret_cast<const __m128i*>(_Src));
 }

static __m128i _Sign_correction(const __m128i _Val, constbool _Sign) noexcept {
alignas(16) staticconstexpr _Unsigned_t _Sign_corrections[2][16] = {
 {0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80}, {}};
return_mm_sub_epi8(_Val, _mm_load_si128(reinterpret_cast<const __m128i*>(_Sign_corrections[_Sign])));
 }

static __m128i _Inc(const __m128i _Idx) noexcept {
return_mm_add_epi8(_Idx, _mm_set1_epi8(1));
 }

template <class_Fn>
static __m128i _H_func(const __m128i _Cur, _Fn _Funct) noexcept {
const __m128i _Shuf_bytes = _mm_set_epi8(14, 15, 12, 13, 10, 11, 8, 9, 6, 7, 4, 5, 2, 3, 0, 1);
const __m128i _Shuf_words = _mm_set_epi8(13, 12, 15, 14, 9, 8, 11, 10, 5, 4, 7, 6, 1, 0, 3, 2);

 __m128i _H_min_val = _Cur;
 _H_min_val = _Funct(_H_min_val, _mm_shuffle_epi32(_H_min_val, _MM_SHUFFLE(1, 0, 3, 2)));
 _H_min_val = _Funct(_H_min_val, _mm_shuffle_epi32(_H_min_val, _MM_SHUFFLE(2, 3, 0, 1)));
 _H_min_val = _Funct(_H_min_val, _mm_shuffle_epi8(_H_min_val, _Shuf_words));
 _H_min_val = _Funct(_H_min_val, _mm_shuffle_epi8(_H_min_val, _Shuf_bytes));
return _H_min_val;
 }

static __m128i _H_min(const __m128i _Cur) noexcept {
return_H_func(_Cur, [](__m128i _Val1, __m128i _Val2) { return_mm_min_epi8(_Val1, _Val2); });
 }

static __m128i _H_max(const __m128i _Cur) noexcept {
return_H_func(_Cur, [](__m128i _Val1, __m128i _Val2) { return_mm_max_epi8(_Val1, _Val2); });
 }

static __m128i _H_min_u(const __m128i _Cur) noexcept {
return_H_func(_Cur, [](__m128i _Val1, __m128i _Val2) { return_mm_min_epu8(_Val1, _Val2); });
 }

static __m128i _H_max_u(const __m128i _Cur) noexcept {
return_H_func(_Cur, [](__m128i _Val1, __m128i _Val2) { return_mm_max_epu8(_Val1, _Val2); });
 }

static _Signed_t _Get_any(const __m128i _Cur) noexcept {
returnstatic_cast<_Signed_t>(_mm_cvtsi128_si32(_Cur));
 }

static _Unsigned_t _Get_v_pos(const __m128i _Idx, constunsignedlong _H_pos) noexcept {
returnstatic_cast<_Unsigned_t>(_mm_cvtsi128_si32(_mm_shuffle_epi8(_Idx, _mm_cvtsi32_si128(_H_pos))));
 }

static __m128i _Cmp_eq(const __m128i _First, const __m128i _Second) noexcept {
return_mm_cmpeq_epi8(_First, _Second);
 }

static __m128i _Cmp_gt(const __m128i _First, const __m128i _Second) noexcept {
return_mm_cmpgt_epi8(_First, _Second);
 }

static __m128i _Cmp_eq_idx(const __m128i _First, const __m128i _Second) noexcept {
return_mm_cmpeq_epi8(_First, _Second);
 }

static __m128i _Min(const __m128i _First, const __m128i _Second, __m128i = _mm_undefined_si128()) noexcept {
return_mm_min_epi8(_First, _Second);
 }

static __m128i _Max(const __m128i _First, const __m128i _Second, __m128i = _mm_undefined_si128()) noexcept {
return_mm_max_epi8(_First, _Second);
 }

static __m128i _Min_u(const __m128i _First, const __m128i _Second) noexcept {
return_mm_min_epu8(_First, _Second);
 }

static __m128i _Max_u(const __m128i _First, const __m128i _Second) noexcept {
return_mm_max_epu8(_First, _Second);
 }

static __m128i _Mask_cast(const __m128i _Mask) noexcept {
return _Mask;
 }
 };

struct_Minmax_traits_1_avx : _Minmax_traits_1_base, _Minmax_traits_avx_i_base {
static __m256i _Load(constvoid* _Src) noexcept {
return_mm256_loadu_si256(reinterpret_cast<const __m256i*>(_Src));
 }

static __m256i _Sign_correction(const __m256i _Val, constbool _Sign) noexcept {
alignas(32) staticconstexpr _Unsigned_t _Sign_corrections[2][32] = {
 {0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80},
 {}};
return_mm256_sub_epi8(_Val, _mm256_load_si256(reinterpret_cast<const __m256i*>(_Sign_corrections[_Sign])));
 }

static __m256i _Inc(const __m256i _Idx) noexcept {
return_mm256_add_epi8(_Idx, _mm256_set1_epi8(1));
 }

template <class_Fn>
static __m256i _H_func(const __m256i _Cur, _Fn _Funct) noexcept {
const __m128i _Shuf_bytes = _mm_set_epi8(14, 15, 12, 13, 10, 11, 8, 9, 6, 7, 4, 5, 2, 3, 0, 1);
const __m128i _Shuf_words = _mm_set_epi8(13, 12, 15, 14, 9, 8, 11, 10, 5, 4, 7, 6, 1, 0, 3, 2);

 __m256i _H_min_val = _Cur;
 _H_min_val = _Funct(_H_min_val, _mm256_permute4x64_epi64(_H_min_val, _MM_SHUFFLE(1, 0, 3, 2)));
 _H_min_val = _Funct(_H_min_val, _mm256_shuffle_epi32(_H_min_val, _MM_SHUFFLE(1, 0, 3, 2)));
 _H_min_val = _Funct(_H_min_val, _mm256_shuffle_epi32(_H_min_val, _MM_SHUFFLE(2, 3, 0, 1)));
 _H_min_val = _Funct(_H_min_val, _mm256_shuffle_epi8(_H_min_val, _mm256_broadcastsi128_si256(_Shuf_words)));
 _H_min_val = _Funct(_H_min_val, _mm256_shuffle_epi8(_H_min_val, _mm256_broadcastsi128_si256(_Shuf_bytes)));
return _H_min_val;
 }

static __m256i _H_min(const __m256i _Cur) noexcept {
return_H_func(_Cur, [](__m256i _Val1, __m256i _Val2) { return_mm256_min_epi8(_Val1, _Val2); });
 }

static __m256i _H_max(const __m256i _Cur) noexcept {
return_H_func(_Cur, [](__m256i _Val1, __m256i _Val2) { return_mm256_max_epi8(_Val1, _Val2); });
 }

static __m256i _H_min_u(const __m256i _Cur) noexcept {
return_H_func(_Cur, [](__m256i _Val1, __m256i _Val2) { return_mm256_min_epu8(_Val1, _Val2); });
 }

static __m256i _H_max_u(const __m256i _Cur) noexcept {
return_H_func(_Cur, [](__m256i _Val1, __m256i _Val2) { return_mm256_max_epu8(_Val1, _Val2); });
 }

static _Signed_t _Get_any(const __m256i _Cur) noexcept {
returnstatic_cast<_Signed_t>(_mm256_cvtsi256_si32(_Cur));
 }

static _Unsigned_t _Get_v_pos(const __m256i _Idx, constunsignedlong _H_pos) noexcept {
constuint32_t _Part = _mm256_cvtsi256_si32(
_mm256_permutevar8x32_epi32(_Idx, _mm256_castsi128_si256(_mm_cvtsi32_si128(_H_pos >> 2))));
returnstatic_cast<_Unsigned_t>(_Part >> ((_H_pos & 0x3) << 3));
 }

static __m256i _Cmp_eq(const __m256i _First, const __m256i _Second) noexcept {
return_mm256_cmpeq_epi8(_First, _Second);
 }

static __m256i _Cmp_gt(const __m256i _First, const __m256i _Second) noexcept {
return_mm256_cmpgt_epi8(_First, _Second);
 }

static __m256i _Cmp_eq_idx(const __m256i _First, const __m256i _Second) noexcept {
return_mm256_cmpeq_epi8(_First, _Second);
 }

static __m256i _Min(const __m256i _First, const __m256i _Second, __m256i = _mm256_undefined_si256()) noexcept {
return_mm256_min_epi8(_First, _Second);
 }

static __m256i _Max(const __m256i _First, const __m256i _Second, __m256i = _mm256_undefined_si256()) noexcept {
return_mm256_max_epi8(_First, _Second);
 }

static __m256i _Min_u(const __m256i _First, const __m256i _Second) noexcept {
return_mm256_min_epu8(_First, _Second);
 }

static __m256i _Max_u(const __m256i _First, const __m256i _Second) noexcept {
return_mm256_max_epu8(_First, _Second);
 }

static __m256i _Mask_cast(const __m256i _Mask) noexcept {
return _Mask;
 }
 };
#endif// !defined(_M_ARM64EC)

struct_Minmax_traits_2_base {
staticconstexprbool _Is_floating = false;

using _Signed_t = int16_t;
using _Unsigned_t = uint16_t;

staticconstexpr _Signed_t _Init_min_val = static_cast<_Signed_t>(0x7FFF);
staticconstexpr _Signed_t _Init_max_val = static_cast<_Signed_t>(0x8000);

using _Minmax_i_t = _Min_max_2i;
using _Minmax_u_t = _Min_max_2u;

#ifndef _M_ARM64EC
staticconstexprbool _Has_portion_max = true;
staticconstexprsize_t _Portion_max = 65536;
#endif// !defined(_M_ARM64EC)
 };

#ifndef _M_ARM64EC
struct_Minmax_traits_2_sse : _Minmax_traits_2_base, _Minmax_traits_sse_base {
static __m128i _Load(constvoid* _Src) noexcept {
return_mm_loadu_si128(reinterpret_cast<const __m128i*>(_Src));
 }

static __m128i _Sign_correction(const __m128i _Val, constbool _Sign) noexcept {
alignas(16) staticconstexpr _Unsigned_t _Sign_corrections[2][8] = {
0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, {}};
return_mm_sub_epi16(_Val, _mm_load_si128(reinterpret_cast<const __m128i*>(_Sign_corrections[_Sign])));
 }

static __m128i _Inc(const __m128i _Idx) noexcept {
return_mm_add_epi16(_Idx, _mm_set1_epi16(1));
 }

template <class_Fn>
static __m128i _H_func(const __m128i _Cur, _Fn _Funct) noexcept {
const __m128i _Shuf_words = _mm_set_epi8(13, 12, 15, 14, 9, 8, 11, 10, 5, 4, 7, 6, 1, 0, 3, 2);

 __m128i _H_min_val = _Cur;
 _H_min_val = _Funct(_H_min_val, _mm_shuffle_epi32(_H_min_val, _MM_SHUFFLE(1, 0, 3, 2)));
 _H_min_val = _Funct(_H_min_val, _mm_shuffle_epi32(_H_min_val, _MM_SHUFFLE(2, 3, 0, 1)));
 _H_min_val = _Funct(_H_min_val, _mm_shuffle_epi8(_H_min_val, _Shuf_words));
return _H_min_val;
 }

static __m128i _H_min(const __m128i _Cur) noexcept {
return_H_func(_Cur, [](__m128i _Val1, __m128i _Val2) { return_mm_min_epi16(_Val1, _Val2); });
 }

static __m128i _H_max(const __m128i _Cur) noexcept {
return_H_func(_Cur, [](__m128i _Val1, __m128i _Val2) { return_mm_max_epi16(_Val1, _Val2); });
 }

static __m128i _H_min_u(const __m128i _Cur) noexcept {
return_H_func(_Cur, [](__m128i _Val1, __m128i _Val2) { return_mm_min_epu16(_Val1, _Val2); });
 }

static __m128i _H_max_u(const __m128i _Cur) noexcept {
return_H_func(_Cur, [](__m128i _Val1, __m128i _Val2) { return_mm_max_epu16(_Val1, _Val2); });
 }

static _Signed_t _Get_any(const __m128i _Cur) noexcept {
returnstatic_cast<_Signed_t>(_mm_cvtsi128_si32(_Cur));
 }

static _Unsigned_t _Get_v_pos(const __m128i _Idx, constunsignedlong _H_pos) noexcept {
staticconstexpr _Unsigned_t _Shuf[] = {0x0100, 0x0302, 0x0504, 0x0706, 0x0908, 0x0B0A, 0x0D0C, 0x0F0E};

returnstatic_cast<_Unsigned_t>(
_mm_cvtsi128_si32(_mm_shuffle_epi8(_Idx, _mm_cvtsi32_si128(_Shuf[_H_pos >> 1]))));
 }

static __m128i _Cmp_eq(const __m128i _First, const __m128i _Second) noexcept {
return_mm_cmpeq_epi16(_First, _Second);
 }

static __m128i _Cmp_gt(const __m128i _First, const __m128i _Second) noexcept {
return_mm_cmpgt_epi16(_First, _Second);
 }

static __m128i _Cmp_eq_idx(const __m128i _First, const __m128i _Second) noexcept {
return_mm_cmpeq_epi16(_First, _Second);
 }

static __m128i _Min(const __m128i _First, const __m128i _Second, __m128i = _mm_undefined_si128()) noexcept {
return_mm_min_epi16(_First, _Second);
 }

static __m128i _Max(const __m128i _First, const __m128i _Second, __m128i = _mm_undefined_si128()) noexcept {
return_mm_max_epi16(_First, _Second);
 }

static __m128i _Min_u(const __m128i _First, const __m128i _Second) noexcept {
return_mm_min_epu16(_First, _Second);
 }

static __m128i _Max_u(const __m128i _First, const __m128i _Second) noexcept {
return_mm_max_epu16(_First, _Second);
 }

static __m128i _Mask_cast(const __m128i _Mask) noexcept {
return _Mask;
 }
 };

struct_Minmax_traits_2_avx : _Minmax_traits_2_base, _Minmax_traits_avx_i_base {
static __m256i _Load(constvoid* _Src) noexcept {
return_mm256_loadu_si256(reinterpret_cast<const __m256i*>(_Src));
 }

static __m256i _Sign_correction(const __m256i _Val, constbool _Sign) noexcept {
alignas(32) staticconstexpr _Unsigned_t _Sign_corrections[2][16] = {0x8000, 0x8000, 0x8000, 0x8000, 0x8000,
0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, {}};
return_mm256_sub_epi16(
 _Val, _mm256_load_si256(reinterpret_cast<const __m256i*>(_Sign_corrections[_Sign])));
 }

static __m256i _Inc(const __m256i _Idx) noexcept {
return_mm256_add_epi16(_Idx, _mm256_set1_epi16(1));
 }

template <class_Fn>
static __m256i _H_func(const __m256i _Cur, _Fn _Funct) noexcept {
const __m128i _Shuf_words = _mm_set_epi8(13, 12, 15, 14, 9, 8, 11, 10, 5, 4, 7, 6, 1, 0, 3, 2);

 __m256i _H_min_val = _Cur;
 _H_min_val = _Funct(_H_min_val, _mm256_permute4x64_epi64(_H_min_val, _MM_SHUFFLE(1, 0, 3, 2)));
 _H_min_val = _Funct(_H_min_val, _mm256_shuffle_epi32(_H_min_val, _MM_SHUFFLE(1, 0, 3, 2)));
 _H_min_val = _Funct(_H_min_val, _mm256_shuffle_epi32(_H_min_val, _MM_SHUFFLE(2, 3, 0, 1)));
 _H_min_val = _Funct(_H_min_val, _mm256_shuffle_epi8(_H_min_val, _mm256_broadcastsi128_si256(_Shuf_words)));
return _H_min_val;
 }

static __m256i _H_min(const __m256i _Cur) noexcept {
return_H_func(_Cur, [](__m256i _Val1, __m256i _Val2) { return_mm256_min_epi16(_Val1, _Val2); });
 }

static __m256i _H_max(const __m256i _Cur) noexcept {
return_H_func(_Cur, [](__m256i _Val1, __m256i _Val2) { return_mm256_max_epi16(_Val1, _Val2); });
 }

static __m256i _H_min_u(const __m256i _Cur) noexcept {
return_H_func(_Cur, [](__m256i _Val1, __m256i _Val2) { return_mm256_min_epu16(_Val1, _Val2); });
 }

static __m256i _H_max_u(const __m256i _Cur) noexcept {
return_H_func(_Cur, [](__m256i _Val1, __m256i _Val2) { return_mm256_max_epu16(_Val1, _Val2); });
 }

static _Signed_t _Get_any(const __m256i _Cur) noexcept {
returnstatic_cast<_Signed_t>(_mm256_cvtsi256_si32(_Cur));
 }

static _Unsigned_t _Get_v_pos(const __m256i _Idx, constunsignedlong _H_pos) noexcept {
constuint32_t _Part = _mm256_cvtsi256_si32(
_mm256_permutevar8x32_epi32(_Idx, _mm256_castsi128_si256(_mm_cvtsi32_si128(_H_pos >> 2))));
returnstatic_cast<_Unsigned_t>(_Part >> ((_H_pos & 0x2) << 3));
 }

static __m256i _Cmp_eq(const __m256i _First, const __m256i _Second) noexcept {
return_mm256_cmpeq_epi16(_First, _Second);
 }

static __m256i _Cmp_gt(const __m256i _First, const __m256i _Second) noexcept {
return_mm256_cmpgt_epi16(_First, _Second);
 }

static __m256i _Cmp_eq_idx(const __m256i _First, const __m256i _Second) noexcept {
return_mm256_cmpeq_epi16(_First, _Second);
 }

static __m256i _Min(const __m256i _First, const __m256i _Second, __m256i = _mm256_undefined_si256()) noexcept {
return_mm256_min_epi16(_First, _Second);
 }

static __m256i _Max(const __m256i _First, const __m256i _Second, __m256i = _mm256_undefined_si256()) noexcept {
return_mm256_max_epi16(_First, _Second);
 }

static __m256i _Min_u(const __m256i _First, const __m256i _Second) noexcept {
return_mm256_min_epu16(_First, _Second);
 }

static __m256i _Max_u(const __m256i _First, const __m256i _Second) noexcept {
return_mm256_max_epu16(_First, _Second);
 }

static __m256i _Mask_cast(const __m256i _Mask) noexcept {
return _Mask;
 }
 };