native.x86.bitalg.ccm

// SPDX-License-Identifier: BSD-2-Clause OR Apache-2.0
module;
#include "native/isa_import.h"
#include "native/x86/bitalg.h"
export module native.x86.bitalg;
export import native.x86.features;
export import native.simd;
// SPDX-License-Identifier: BSD-2-Clause OR Apache-2.0
 
#if NATIVE_HOST_X86 || defined(NATIVE_DOXYGEN)
export namespace native {

  template<isa<x86> Arch>
    requires(Arch.has(x86_feature::avx512f) &&
      Arch.has(x86_feature::avx512bw) &&
      Arch.has(x86_feature::avx512bitalg) &&
      Arch.has(x86_feature::avx512vl))
  native_nodiscard native_inline native_const native_target("avx512f,avx512bw,avx512bitalg,avx512vl")
  constexpr simd<std::uint8_t, 16, Arch> vpopcntb(
    simd<std::uint8_t, 16, Arch> value) noexcept {
    if consteval {
      return detail::x86_bitalg_constant::population(
        value, simd<std::uint8_t, 16, Arch>{}, ~std::uint64_t{0});
    } else {
      return simd<std::uint8_t, 16, Arch>::from_native(
        detail::x86_bitalg::vpopcntb<Arch>(value.to_native()));
    }
  }

  template<isa<x86> Arch>
    requires(Arch.has(x86_feature::avx512f) &&
      Arch.has(x86_feature::avx512bw) &&
      Arch.has(x86_feature::avx512bitalg) &&
      Arch.has(x86_feature::avx512vl))
  native_nodiscard native_inline native_const native_target("avx512f,avx512bw,avx512bitalg,avx512vl")
  constexpr simd<std::uint8_t, 16, Arch> mask_vpopcntb(
    simd<std::uint8_t, 16, Arch> source,
    predicate<16, Arch> mask,
    simd<std::uint8_t, 16, Arch> value) noexcept {
    if consteval {
      return detail::x86_bitalg_constant::population(
        value, source, mask.to_bitset());
    } else {
      return simd<std::uint8_t, 16, Arch>::from_native(
        detail::x86_bitalg::mask_vpopcntb<Arch>(source.to_native(), mask.to_bitset(), value.to_native()));
    }
  }

  template<isa<x86> Arch>
    requires(Arch.has(x86_feature::avx512f) &&
      Arch.has(x86_feature::avx512bw) &&
      Arch.has(x86_feature::avx512bitalg) &&
      Arch.has(x86_feature::avx512vl))
  native_nodiscard native_inline native_const native_target("avx512f,avx512bw,avx512bitalg,avx512vl")
  constexpr simd<std::uint8_t, 16, Arch> maskz_vpopcntb(
    predicate<16, Arch> mask,
    simd<std::uint8_t, 16, Arch> value) noexcept {
    if consteval {
      return detail::x86_bitalg_constant::population(
        value, simd<std::uint8_t, 16, Arch>{}, mask.to_bitset());
    } else {
      return simd<std::uint8_t, 16, Arch>::from_native(
        detail::x86_bitalg::maskz_vpopcntb<Arch>(mask.to_bitset(), value.to_native()));
    }
  }

  template<isa<x86> Arch>
    requires(Arch.has(x86_feature::avx512f) &&
      Arch.has(x86_feature::avx512bw) &&
      Arch.has(x86_feature::avx512bitalg) &&
      Arch.has(x86_feature::avx512vl))
  native_nodiscard native_inline native_const native_target("avx512f,avx512bw,avx512bitalg,avx512vl")
  constexpr simd<std::uint16_t, 8, Arch> vpopcntw(
    simd<std::uint16_t, 8, Arch> value) noexcept {
    if consteval {
      return detail::x86_bitalg_constant::population(
        value, simd<std::uint16_t, 8, Arch>{}, ~std::uint64_t{0});
    } else {
      return simd<std::uint16_t, 8, Arch>::from_native(
        detail::x86_bitalg::vpopcntw<Arch>(value.to_native()));
    }
  }

  template<isa<x86> Arch>
    requires(Arch.has(x86_feature::avx512f) &&
      Arch.has(x86_feature::avx512bw) &&
      Arch.has(x86_feature::avx512bitalg) &&
      Arch.has(x86_feature::avx512vl))
  native_nodiscard native_inline native_const native_target("avx512f,avx512bw,avx512bitalg,avx512vl")
  constexpr simd<std::uint16_t, 8, Arch> mask_vpopcntw(
    simd<std::uint16_t, 8, Arch> source,
    predicate<8, Arch> mask,
    simd<std::uint16_t, 8, Arch> value) noexcept {
    if consteval {
      return detail::x86_bitalg_constant::population(
        value, source, mask.to_bitset());
    } else {
      return simd<std::uint16_t, 8, Arch>::from_native(
        detail::x86_bitalg::mask_vpopcntw<Arch>(source.to_native(), mask.to_bitset(), value.to_native()));
    }
  }

  template<isa<x86> Arch>
    requires(Arch.has(x86_feature::avx512f) &&
      Arch.has(x86_feature::avx512bw) &&
      Arch.has(x86_feature::avx512bitalg) &&
      Arch.has(x86_feature::avx512vl))
  native_nodiscard native_inline native_const native_target("avx512f,avx512bw,avx512bitalg,avx512vl")
  constexpr simd<std::uint16_t, 8, Arch> maskz_vpopcntw(
    predicate<8, Arch> mask,
    simd<std::uint16_t, 8, Arch> value) noexcept {
    if consteval {
      return detail::x86_bitalg_constant::population(
        value, simd<std::uint16_t, 8, Arch>{}, mask.to_bitset());
    } else {
      return simd<std::uint16_t, 8, Arch>::from_native(
        detail::x86_bitalg::maskz_vpopcntw<Arch>(mask.to_bitset(), value.to_native()));
    }
  }

  template<isa<x86> Arch>
    requires(Arch.has(x86_feature::avx512f) &&
      Arch.has(x86_feature::avx512bw) &&
      Arch.has(x86_feature::avx512bitalg) &&
      Arch.has(x86_feature::avx512vl))
  native_nodiscard native_inline native_const native_target("avx512f,avx512bw,avx512bitalg,avx512vl")
  constexpr predicate<16, Arch> vpshufbitqmb(
    simd<std::uint64_t, 2, Arch> value,
    simd<std::uint8_t, 16, Arch> control) noexcept {
    if consteval {
      return detail::x86_bitalg_constant::bitshuffle<predicate<16, Arch>>(
        value, control, ~std::uint64_t{0});
    } else {
      return predicate<16, Arch>::from_bitset(
        detail::x86_bitalg::vpshufbitqmb<Arch>(value.to_native(), control.to_native()));
    }
  }

  template<isa<x86> Arch>
    requires(Arch.has(x86_feature::avx512f) &&
      Arch.has(x86_feature::avx512bw) &&
      Arch.has(x86_feature::avx512bitalg) &&
      Arch.has(x86_feature::avx512vl))
  native_nodiscard native_inline native_const native_target("avx512f,avx512bw,avx512bitalg,avx512vl")
  constexpr predicate<16, Arch> mask_vpshufbitqmb(
    predicate<16, Arch> mask,
    simd<std::uint64_t, 2, Arch> value,
    simd<std::uint8_t, 16, Arch> control) noexcept {
    if consteval {
      return detail::x86_bitalg_constant::bitshuffle<predicate<16, Arch>>(
        value, control, mask.to_bitset());
    } else {
      return predicate<16, Arch>::from_bitset(
        detail::x86_bitalg::mask_vpshufbitqmb<Arch>(
          mask.to_bitset(),
          value.to_native(),
          control.to_native()));
    }
  }

  template<isa<x86> Arch>
    requires(Arch.has(x86_feature::avx512f) &&
      Arch.has(x86_feature::avx512bw) &&
      Arch.has(x86_feature::avx512bitalg) &&
      Arch.has(x86_feature::avx512vl))
  native_nodiscard native_inline native_const native_target("avx512f,avx512bw,avx512bitalg,avx512vl")
  constexpr simd<std::uint8_t, 32, Arch> vpopcntb(
    simd<std::uint8_t, 32, Arch> value) noexcept {
    if consteval {
      return detail::x86_bitalg_constant::population(
        value, simd<std::uint8_t, 32, Arch>{}, ~std::uint64_t{0});
    } else {
      return simd<std::uint8_t, 32, Arch>::from_native(
        detail::x86_bitalg::vpopcntb<Arch>(value.to_native()));
    }
  }

  template<isa<x86> Arch>
    requires(Arch.has(x86_feature::avx512f) &&
      Arch.has(x86_feature::avx512bw) &&
      Arch.has(x86_feature::avx512bitalg) &&
      Arch.has(x86_feature::avx512vl))
  native_nodiscard native_inline native_const native_target("avx512f,avx512bw,avx512bitalg,avx512vl")
  constexpr simd<std::uint8_t, 32, Arch> mask_vpopcntb(
    simd<std::uint8_t, 32, Arch> source,
    predicate<32, Arch> mask,
    simd<std::uint8_t, 32, Arch> value) noexcept {
    if consteval {
      return detail::x86_bitalg_constant::population(
        value, source, mask.to_bitset());
    } else {
      return simd<std::uint8_t, 32, Arch>::from_native(
        detail::x86_bitalg::mask_vpopcntb<Arch>(source.to_native(), mask.to_bitset(), value.to_native()));
    }
  }

  template<isa<x86> Arch>
    requires(Arch.has(x86_feature::avx512f) &&
      Arch.has(x86_feature::avx512bw) &&
      Arch.has(x86_feature::avx512bitalg) &&
      Arch.has(x86_feature::avx512vl))
  native_nodiscard native_inline native_const native_target("avx512f,avx512bw,avx512bitalg,avx512vl")
  constexpr simd<std::uint8_t, 32, Arch> maskz_vpopcntb(
    predicate<32, Arch> mask,
    simd<std::uint8_t, 32, Arch> value) noexcept {
    if consteval {
      return detail::x86_bitalg_constant::population(
        value, simd<std::uint8_t, 32, Arch>{}, mask.to_bitset());
    } else {
      return simd<std::uint8_t, 32, Arch>::from_native(
        detail::x86_bitalg::maskz_vpopcntb<Arch>(mask.to_bitset(), value.to_native()));
    }
  }

  template<isa<x86> Arch>
    requires(Arch.has(x86_feature::avx512f) &&
      Arch.has(x86_feature::avx512bw) &&
      Arch.has(x86_feature::avx512bitalg) &&
      Arch.has(x86_feature::avx512vl))
  native_nodiscard native_inline native_const native_target("avx512f,avx512bw,avx512bitalg,avx512vl")
  constexpr simd<std::uint16_t, 16, Arch> vpopcntw(
    simd<std::uint16_t, 16, Arch> value) noexcept {
    if consteval {
      return detail::x86_bitalg_constant::population(
        value, simd<std::uint16_t, 16, Arch>{}, ~std::uint64_t{0});
    } else {
      return simd<std::uint16_t, 16, Arch>::from_native(
        detail::x86_bitalg::vpopcntw<Arch>(value.to_native()));
    }
  }

  template<isa<x86> Arch>
    requires(Arch.has(x86_feature::avx512f) &&
      Arch.has(x86_feature::avx512bw) &&
      Arch.has(x86_feature::avx512bitalg) &&
      Arch.has(x86_feature::avx512vl))
  native_nodiscard native_inline native_const native_target("avx512f,avx512bw,avx512bitalg,avx512vl")
  constexpr simd<std::uint16_t, 16, Arch> mask_vpopcntw(
    simd<std::uint16_t, 16, Arch> source,
    predicate<16, Arch> mask,
    simd<std::uint16_t, 16, Arch> value) noexcept {
    if consteval {
      return detail::x86_bitalg_constant::population(
        value, source, mask.to_bitset());
    } else {
      return simd<std::uint16_t, 16, Arch>::from_native(
        detail::x86_bitalg::mask_vpopcntw<Arch>(source.to_native(), mask.to_bitset(), value.to_native()));
    }
  }

  template<isa<x86> Arch>
    requires(Arch.has(x86_feature::avx512f) &&
      Arch.has(x86_feature::avx512bw) &&
      Arch.has(x86_feature::avx512bitalg) &&
      Arch.has(x86_feature::avx512vl))
  native_nodiscard native_inline native_const native_target("avx512f,avx512bw,avx512bitalg,avx512vl")
  constexpr simd<std::uint16_t, 16, Arch> maskz_vpopcntw(
    predicate<16, Arch> mask,
    simd<std::uint16_t, 16, Arch> value) noexcept {
    if consteval {
      return detail::x86_bitalg_constant::population(
        value, simd<std::uint16_t, 16, Arch>{}, mask.to_bitset());
    } else {
      return simd<std::uint16_t, 16, Arch>::from_native(
        detail::x86_bitalg::maskz_vpopcntw<Arch>(mask.to_bitset(), value.to_native()));
    }
  }

  template<isa<x86> Arch>
    requires(Arch.has(x86_feature::avx512f) &&
      Arch.has(x86_feature::avx512bw) &&
      Arch.has(x86_feature::avx512bitalg) &&
      Arch.has(x86_feature::avx512vl))
  native_nodiscard native_inline native_const native_target("avx512f,avx512bw,avx512bitalg,avx512vl")
  constexpr predicate<32, Arch> vpshufbitqmb(
    simd<std::uint64_t, 4, Arch> value,
    simd<std::uint8_t, 32, Arch> control) noexcept {
    if consteval {
      return detail::x86_bitalg_constant::bitshuffle<predicate<32, Arch>>(
        value, control, ~std::uint64_t{0});
    } else {
      return predicate<32, Arch>::from_bitset(
        detail::x86_bitalg::vpshufbitqmb<Arch>(value.to_native(), control.to_native()));
    }
  }

  template<isa<x86> Arch>
    requires(Arch.has(x86_feature::avx512f) &&
      Arch.has(x86_feature::avx512bw) &&
      Arch.has(x86_feature::avx512bitalg) &&
      Arch.has(x86_feature::avx512vl))
  native_nodiscard native_inline native_const native_target("avx512f,avx512bw,avx512bitalg,avx512vl")
  constexpr predicate<32, Arch> mask_vpshufbitqmb(
    predicate<32, Arch> mask,
    simd<std::uint64_t, 4, Arch> value,
    simd<std::uint8_t, 32, Arch> control) noexcept {
    if consteval {
      return detail::x86_bitalg_constant::bitshuffle<predicate<32, Arch>>(
        value, control, mask.to_bitset());
    } else {
      return predicate<32, Arch>::from_bitset(
        detail::x86_bitalg::mask_vpshufbitqmb<Arch>(
          mask.to_bitset(),
          value.to_native(),
          control.to_native()));
    }
  }

  template<isa<x86> Arch>
    requires(Arch.has(x86_feature::avx512f) &&
      Arch.has(x86_feature::avx512bw) &&
      Arch.has(x86_feature::avx512bitalg))
  native_nodiscard native_inline native_const native_target("avx512f,avx512bw,avx512bitalg")
  constexpr simd<std::uint8_t, 64, Arch> vpopcntb(
    simd<std::uint8_t, 64, Arch> value) noexcept {
    if consteval {
      return detail::x86_bitalg_constant::population(
        value, simd<std::uint8_t, 64, Arch>{}, ~std::uint64_t{0});
    } else {
      return simd<std::uint8_t, 64, Arch>::from_native(
        detail::x86_bitalg::vpopcntb<Arch>(value.to_native()));
    }
  }

  template<isa<x86> Arch>
    requires(Arch.has(x86_feature::avx512f) &&
      Arch.has(x86_feature::avx512bw) &&
      Arch.has(x86_feature::avx512bitalg))
  native_nodiscard native_inline native_const native_target("avx512f,avx512bw,avx512bitalg")
  constexpr simd<std::uint8_t, 64, Arch> mask_vpopcntb(
    simd<std::uint8_t, 64, Arch> source,
    predicate<64, Arch> mask,
    simd<std::uint8_t, 64, Arch> value) noexcept {
    if consteval {
      return detail::x86_bitalg_constant::population(
        value, source, mask.to_bitset());
    } else {
      return simd<std::uint8_t, 64, Arch>::from_native(
        detail::x86_bitalg::mask_vpopcntb<Arch>(source.to_native(), mask.to_bitset(), value.to_native()));
    }
  }

  template<isa<x86> Arch>
    requires(Arch.has(x86_feature::avx512f) &&
      Arch.has(x86_feature::avx512bw) &&
      Arch.has(x86_feature::avx512bitalg))
  native_nodiscard native_inline native_const native_target("avx512f,avx512bw,avx512bitalg")
  constexpr simd<std::uint8_t, 64, Arch> maskz_vpopcntb(
    predicate<64, Arch> mask,
    simd<std::uint8_t, 64, Arch> value) noexcept {
    if consteval {
      return detail::x86_bitalg_constant::population(
        value, simd<std::uint8_t, 64, Arch>{}, mask.to_bitset());
    } else {
      return simd<std::uint8_t, 64, Arch>::from_native(
        detail::x86_bitalg::maskz_vpopcntb<Arch>(mask.to_bitset(), value.to_native()));
    }
  }

  template<isa<x86> Arch>
    requires(Arch.has(x86_feature::avx512f) &&
      Arch.has(x86_feature::avx512bw) &&
      Arch.has(x86_feature::avx512bitalg))
  native_nodiscard native_inline native_const native_target("avx512f,avx512bw,avx512bitalg")
  constexpr simd<std::uint16_t, 32, Arch> vpopcntw(
    simd<std::uint16_t, 32, Arch> value) noexcept {
    if consteval {
      return detail::x86_bitalg_constant::population(
        value, simd<std::uint16_t, 32, Arch>{}, ~std::uint64_t{0});
    } else {
      return simd<std::uint16_t, 32, Arch>::from_native(
        detail::x86_bitalg::vpopcntw<Arch>(value.to_native()));
    }
  }

  template<isa<x86> Arch>
    requires(Arch.has(x86_feature::avx512f) &&
      Arch.has(x86_feature::avx512bw) &&
      Arch.has(x86_feature::avx512bitalg))
  native_nodiscard native_inline native_const native_target("avx512f,avx512bw,avx512bitalg")
  constexpr simd<std::uint16_t, 32, Arch> mask_vpopcntw(
    simd<std::uint16_t, 32, Arch> source,
    predicate<32, Arch> mask,
    simd<std::uint16_t, 32, Arch> value) noexcept {
    if consteval {
      return detail::x86_bitalg_constant::population(
        value, source, mask.to_bitset());
    } else {
      return simd<std::uint16_t, 32, Arch>::from_native(
        detail::x86_bitalg::mask_vpopcntw<Arch>(source.to_native(), mask.to_bitset(), value.to_native()));
    }
  }

  template<isa<x86> Arch>
    requires(Arch.has(x86_feature::avx512f) &&
      Arch.has(x86_feature::avx512bw) &&
      Arch.has(x86_feature::avx512bitalg))
  native_nodiscard native_inline native_const native_target("avx512f,avx512bw,avx512bitalg")
  constexpr simd<std::uint16_t, 32, Arch> maskz_vpopcntw(
    predicate<32, Arch> mask,
    simd<std::uint16_t, 32, Arch> value) noexcept {
    if consteval {
      return detail::x86_bitalg_constant::population(
        value, simd<std::uint16_t, 32, Arch>{}, mask.to_bitset());
    } else {
      return simd<std::uint16_t, 32, Arch>::from_native(
        detail::x86_bitalg::maskz_vpopcntw<Arch>(mask.to_bitset(), value.to_native()));
    }
  }

  template<isa<x86> Arch>
    requires(Arch.has(x86_feature::avx512f) &&
      Arch.has(x86_feature::avx512bw) &&
      Arch.has(x86_feature::avx512bitalg))
  native_nodiscard native_inline native_const native_target("avx512f,avx512bw,avx512bitalg")
  constexpr predicate<64, Arch> vpshufbitqmb(
    simd<std::uint64_t, 8, Arch> value,
    simd<std::uint8_t, 64, Arch> control) noexcept {
    if consteval {
      return detail::x86_bitalg_constant::bitshuffle<predicate<64, Arch>>(
        value, control, ~std::uint64_t{0});
    } else {
      return predicate<64, Arch>::from_bitset(
        detail::x86_bitalg::vpshufbitqmb<Arch>(value.to_native(), control.to_native()));
    }
  }

  template<isa<x86> Arch>
    requires(Arch.has(x86_feature::avx512f) &&
      Arch.has(x86_feature::avx512bw) &&
      Arch.has(x86_feature::avx512bitalg))
  native_nodiscard native_inline native_const native_target("avx512f,avx512bw,avx512bitalg")
  constexpr predicate<64, Arch> mask_vpshufbitqmb(
    predicate<64, Arch> mask,
    simd<std::uint64_t, 8, Arch> value,
    simd<std::uint8_t, 64, Arch> control) noexcept {
    if consteval {
      return detail::x86_bitalg_constant::bitshuffle<predicate<64, Arch>>(
        value, control, mask.to_bitset());
    } else {
      return predicate<64, Arch>::from_bitset(
        detail::x86_bitalg::mask_vpshufbitqmb<Arch>(
          mask.to_bitset(),
          value.to_native(),
          control.to_native()));
    }
  }

  template<isa<x86> Arch>
    requires(!(Arch.has(x86_feature::avx512f) &&
      Arch.has(x86_feature::avx512bw) &&
      Arch.has(x86_feature::avx512bitalg) &&
      Arch.has(x86_feature::avx512vl)) &&
      requires { sizeof(simd<std::uint8_t, 16, Arch>); })
  native_nodiscard consteval simd<std::uint8_t, 16, Arch> vpopcntb(
    simd<std::uint8_t, 16, Arch> value) noexcept {
    return detail::x86_bitalg_constant::population(
      value, simd<std::uint8_t, 16, Arch>{}, ~std::uint64_t{0});
  }

  template<isa<x86> Arch>
    requires(!(Arch.has(x86_feature::avx512f) &&
      Arch.has(x86_feature::avx512bw) &&
      Arch.has(x86_feature::avx512bitalg) &&
      Arch.has(x86_feature::avx512vl)) &&
      requires { sizeof(simd<std::uint8_t, 16, Arch>); })
  native_nodiscard consteval simd<std::uint8_t, 16, Arch> mask_vpopcntb(
    simd<std::uint8_t, 16, Arch> source,
    predicate<16, Arch> mask,
    simd<std::uint8_t, 16, Arch> value) noexcept {
    return detail::x86_bitalg_constant::population(
      value, source, mask.to_bitset());
  }

  template<isa<x86> Arch>
    requires(!(Arch.has(x86_feature::avx512f) &&
      Arch.has(x86_feature::avx512bw) &&
      Arch.has(x86_feature::avx512bitalg) &&
      Arch.has(x86_feature::avx512vl)) &&
      requires { sizeof(simd<std::uint8_t, 16, Arch>); })
  native_nodiscard consteval simd<std::uint8_t, 16, Arch> maskz_vpopcntb(
    predicate<16, Arch> mask,
    simd<std::uint8_t, 16, Arch> value) noexcept {
    return detail::x86_bitalg_constant::population(
      value, simd<std::uint8_t, 16, Arch>{}, mask.to_bitset());
  }

  template<isa<x86> Arch>
    requires(!(Arch.has(x86_feature::avx512f) &&
      Arch.has(x86_feature::avx512bw) &&
      Arch.has(x86_feature::avx512bitalg) &&
      Arch.has(x86_feature::avx512vl)) &&
      requires { sizeof(simd<std::uint16_t, 8, Arch>); })
  native_nodiscard consteval simd<std::uint16_t, 8, Arch> vpopcntw(
    simd<std::uint16_t, 8, Arch> value) noexcept {
    return detail::x86_bitalg_constant::population(
      value, simd<std::uint16_t, 8, Arch>{}, ~std::uint64_t{0});
  }

  template<isa<x86> Arch>
    requires(!(Arch.has(x86_feature::avx512f) &&
      Arch.has(x86_feature::avx512bw) &&
      Arch.has(x86_feature::avx512bitalg) &&
      Arch.has(x86_feature::avx512vl)) &&
      requires { sizeof(simd<std::uint16_t, 8, Arch>); })
  native_nodiscard consteval simd<std::uint16_t, 8, Arch> mask_vpopcntw(
    simd<std::uint16_t, 8, Arch> source,
    predicate<8, Arch> mask,
    simd<std::uint16_t, 8, Arch> value) noexcept {
    return detail::x86_bitalg_constant::population(
      value, source, mask.to_bitset());
  }

  template<isa<x86> Arch>
    requires(!(Arch.has(x86_feature::avx512f) &&
      Arch.has(x86_feature::avx512bw) &&
      Arch.has(x86_feature::avx512bitalg) &&
      Arch.has(x86_feature::avx512vl)) &&
      requires { sizeof(simd<std::uint16_t, 8, Arch>); })
  native_nodiscard consteval simd<std::uint16_t, 8, Arch> maskz_vpopcntw(
    predicate<8, Arch> mask,
    simd<std::uint16_t, 8, Arch> value) noexcept {
    return detail::x86_bitalg_constant::population(
      value, simd<std::uint16_t, 8, Arch>{}, mask.to_bitset());
  }

  template<isa<x86> Arch>
    requires(!(Arch.has(x86_feature::avx512f) &&
      Arch.has(x86_feature::avx512bw) &&
      Arch.has(x86_feature::avx512bitalg) &&
      Arch.has(x86_feature::avx512vl)) &&
      requires {
        sizeof(simd<std::uint64_t, 2, Arch>);
        sizeof(simd<std::uint8_t, 16, Arch>);
        sizeof(predicate<16, Arch>);
      })
  native_nodiscard consteval predicate<16, Arch> vpshufbitqmb(
    simd<std::uint64_t, 2, Arch> value,
    simd<std::uint8_t, 16, Arch> control) noexcept {
    return detail::x86_bitalg_constant::bitshuffle<predicate<16, Arch>>(
      value, control, ~std::uint64_t{0});
  }

  template<isa<x86> Arch>
    requires(!(Arch.has(x86_feature::avx512f) &&
      Arch.has(x86_feature::avx512bw) &&
      Arch.has(x86_feature::avx512bitalg) &&
      Arch.has(x86_feature::avx512vl)) &&
      requires {
        sizeof(simd<std::uint64_t, 2, Arch>);
        sizeof(simd<std::uint8_t, 16, Arch>);
        sizeof(predicate<16, Arch>);
      })
  native_nodiscard consteval predicate<16, Arch> mask_vpshufbitqmb(
    predicate<16, Arch> mask,
    simd<std::uint64_t, 2, Arch> value,
    simd<std::uint8_t, 16, Arch> control) noexcept {
    return detail::x86_bitalg_constant::bitshuffle<predicate<16, Arch>>(
      value, control, mask.to_bitset());
  }

  template<isa<x86> Arch>
    requires(!(Arch.has(x86_feature::avx512f) &&
      Arch.has(x86_feature::avx512bw) &&
      Arch.has(x86_feature::avx512bitalg) &&
      Arch.has(x86_feature::avx512vl)) &&
      requires { sizeof(simd<std::uint8_t, 32, Arch>); })
  native_nodiscard consteval simd<std::uint8_t, 32, Arch> vpopcntb(
    simd<std::uint8_t, 32, Arch> value) noexcept {
    return detail::x86_bitalg_constant::population(
      value, simd<std::uint8_t, 32, Arch>{}, ~std::uint64_t{0});
  }

  template<isa<x86> Arch>
    requires(!(Arch.has(x86_feature::avx512f) &&
      Arch.has(x86_feature::avx512bw) &&
      Arch.has(x86_feature::avx512bitalg) &&
      Arch.has(x86_feature::avx512vl)) &&
      requires { sizeof(simd<std::uint8_t, 32, Arch>); })
  native_nodiscard consteval simd<std::uint8_t, 32, Arch> mask_vpopcntb(
    simd<std::uint8_t, 32, Arch> source,
    predicate<32, Arch> mask,
    simd<std::uint8_t, 32, Arch> value) noexcept {
    return detail::x86_bitalg_constant::population(
      value, source, mask.to_bitset());
  }

  template<isa<x86> Arch>
    requires(!(Arch.has(x86_feature::avx512f) &&
      Arch.has(x86_feature::avx512bw) &&
      Arch.has(x86_feature::avx512bitalg) &&
      Arch.has(x86_feature::avx512vl)) &&
      requires { sizeof(simd<std::uint8_t, 32, Arch>); })
  native_nodiscard consteval simd<std::uint8_t, 32, Arch> maskz_vpopcntb(
    predicate<32, Arch> mask,
    simd<std::uint8_t, 32, Arch> value) noexcept {
    return detail::x86_bitalg_constant::population(
      value, simd<std::uint8_t, 32, Arch>{}, mask.to_bitset());
  }

  template<isa<x86> Arch>
    requires(!(Arch.has(x86_feature::avx512f) &&
      Arch.has(x86_feature::avx512bw) &&
      Arch.has(x86_feature::avx512bitalg) &&
      Arch.has(x86_feature::avx512vl)) &&
      requires { sizeof(simd<std::uint16_t, 16, Arch>); })
  native_nodiscard consteval simd<std::uint16_t, 16, Arch> vpopcntw(
    simd<std::uint16_t, 16, Arch> value) noexcept {
    return detail::x86_bitalg_constant::population(
      value, simd<std::uint16_t, 16, Arch>{}, ~std::uint64_t{0});
  }

  template<isa<x86> Arch>
    requires(!(Arch.has(x86_feature::avx512f) &&
      Arch.has(x86_feature::avx512bw) &&
      Arch.has(x86_feature::avx512bitalg) &&
      Arch.has(x86_feature::avx512vl)) &&
      requires { sizeof(simd<std::uint16_t, 16, Arch>); })
  native_nodiscard consteval simd<std::uint16_t, 16, Arch> mask_vpopcntw(
    simd<std::uint16_t, 16, Arch> source,
    predicate<16, Arch> mask,
    simd<std::uint16_t, 16, Arch> value) noexcept {
    return detail::x86_bitalg_constant::population(
      value, source, mask.to_bitset());
  }

  template<isa<x86> Arch>
    requires(!(Arch.has(x86_feature::avx512f) &&
      Arch.has(x86_feature::avx512bw) &&
      Arch.has(x86_feature::avx512bitalg) &&
      Arch.has(x86_feature::avx512vl)) &&
      requires { sizeof(simd<std::uint16_t, 16, Arch>); })
  native_nodiscard consteval simd<std::uint16_t, 16, Arch> maskz_vpopcntw(
    predicate<16, Arch> mask,
    simd<std::uint16_t, 16, Arch> value) noexcept {
    return detail::x86_bitalg_constant::population(
      value, simd<std::uint16_t, 16, Arch>{}, mask.to_bitset());
  }

  template<isa<x86> Arch>
    requires(!(Arch.has(x86_feature::avx512f) &&
      Arch.has(x86_feature::avx512bw) &&
      Arch.has(x86_feature::avx512bitalg) &&
      Arch.has(x86_feature::avx512vl)) &&
      requires {
        sizeof(simd<std::uint64_t, 4, Arch>);
        sizeof(simd<std::uint8_t, 32, Arch>);
        sizeof(predicate<32, Arch>);
      })
  native_nodiscard consteval predicate<32, Arch> vpshufbitqmb(
    simd<std::uint64_t, 4, Arch> value,
    simd<std::uint8_t, 32, Arch> control) noexcept {
    return detail::x86_bitalg_constant::bitshuffle<predicate<32, Arch>>(
      value, control, ~std::uint64_t{0});
  }

  template<isa<x86> Arch>
    requires(!(Arch.has(x86_feature::avx512f) &&
      Arch.has(x86_feature::avx512bw) &&
      Arch.has(x86_feature::avx512bitalg) &&
      Arch.has(x86_feature::avx512vl)) &&
      requires {
        sizeof(simd<std::uint64_t, 4, Arch>);
        sizeof(simd<std::uint8_t, 32, Arch>);
        sizeof(predicate<32, Arch>);
      })
  native_nodiscard consteval predicate<32, Arch> mask_vpshufbitqmb(
    predicate<32, Arch> mask,
    simd<std::uint64_t, 4, Arch> value,
    simd<std::uint8_t, 32, Arch> control) noexcept {
    return detail::x86_bitalg_constant::bitshuffle<predicate<32, Arch>>(
      value, control, mask.to_bitset());
  }

  template<isa<x86> Arch>
    requires(!(Arch.has(x86_feature::avx512f) &&
      Arch.has(x86_feature::avx512bw) &&
      Arch.has(x86_feature::avx512bitalg)) &&
      requires { sizeof(simd<std::uint8_t, 64, Arch>); })
  native_nodiscard consteval simd<std::uint8_t, 64, Arch> vpopcntb(
    simd<std::uint8_t, 64, Arch> value) noexcept {
    return detail::x86_bitalg_constant::population(
      value, simd<std::uint8_t, 64, Arch>{}, ~std::uint64_t{0});
  }

  template<isa<x86> Arch>
    requires(!(Arch.has(x86_feature::avx512f) &&
      Arch.has(x86_feature::avx512bw) &&
      Arch.has(x86_feature::avx512bitalg)) &&
      requires { sizeof(simd<std::uint8_t, 64, Arch>); })
  native_nodiscard consteval simd<std::uint8_t, 64, Arch> mask_vpopcntb(
    simd<std::uint8_t, 64, Arch> source,
    predicate<64, Arch> mask,
    simd<std::uint8_t, 64, Arch> value) noexcept {
    return detail::x86_bitalg_constant::population(
      value, source, mask.to_bitset());
  }

  template<isa<x86> Arch>
    requires(!(Arch.has(x86_feature::avx512f) &&
      Arch.has(x86_feature::avx512bw) &&
      Arch.has(x86_feature::avx512bitalg)) &&
      requires { sizeof(simd<std::uint8_t, 64, Arch>); })
  native_nodiscard consteval simd<std::uint8_t, 64, Arch> maskz_vpopcntb(
    predicate<64, Arch> mask,
    simd<std::uint8_t, 64, Arch> value) noexcept {
    return detail::x86_bitalg_constant::population(
      value, simd<std::uint8_t, 64, Arch>{}, mask.to_bitset());
  }

  template<isa<x86> Arch>
    requires(!(Arch.has(x86_feature::avx512f) &&
      Arch.has(x86_feature::avx512bw) &&
      Arch.has(x86_feature::avx512bitalg)) &&
      requires { sizeof(simd<std::uint16_t, 32, Arch>); })
  native_nodiscard consteval simd<std::uint16_t, 32, Arch> vpopcntw(
    simd<std::uint16_t, 32, Arch> value) noexcept {
    return detail::x86_bitalg_constant::population(
      value, simd<std::uint16_t, 32, Arch>{}, ~std::uint64_t{0});
  }

  template<isa<x86> Arch>
    requires(!(Arch.has(x86_feature::avx512f) &&
      Arch.has(x86_feature::avx512bw) &&
      Arch.has(x86_feature::avx512bitalg)) &&
      requires { sizeof(simd<std::uint16_t, 32, Arch>); })
  native_nodiscard consteval simd<std::uint16_t, 32, Arch> mask_vpopcntw(
    simd<std::uint16_t, 32, Arch> source,
    predicate<32, Arch> mask,
    simd<std::uint16_t, 32, Arch> value) noexcept {
    return detail::x86_bitalg_constant::population(
      value, source, mask.to_bitset());
  }

  template<isa<x86> Arch>
    requires(!(Arch.has(x86_feature::avx512f) &&
      Arch.has(x86_feature::avx512bw) &&
      Arch.has(x86_feature::avx512bitalg)) &&
      requires { sizeof(simd<std::uint16_t, 32, Arch>); })
  native_nodiscard consteval simd<std::uint16_t, 32, Arch> maskz_vpopcntw(
    predicate<32, Arch> mask,
    simd<std::uint16_t, 32, Arch> value) noexcept {
    return detail::x86_bitalg_constant::population(
      value, simd<std::uint16_t, 32, Arch>{}, mask.to_bitset());
  }

  template<isa<x86> Arch>
    requires(!(Arch.has(x86_feature::avx512f) &&
      Arch.has(x86_feature::avx512bw) &&
      Arch.has(x86_feature::avx512bitalg)) &&
      requires {
        sizeof(simd<std::uint64_t, 8, Arch>);
        sizeof(simd<std::uint8_t, 64, Arch>);
        sizeof(predicate<64, Arch>);
      })
  native_nodiscard consteval predicate<64, Arch> vpshufbitqmb(
    simd<std::uint64_t, 8, Arch> value,
    simd<std::uint8_t, 64, Arch> control) noexcept {
    return detail::x86_bitalg_constant::bitshuffle<predicate<64, Arch>>(
      value, control, ~std::uint64_t{0});
  }

  template<isa<x86> Arch>
    requires(!(Arch.has(x86_feature::avx512f) &&
      Arch.has(x86_feature::avx512bw) &&
      Arch.has(x86_feature::avx512bitalg)) &&
      requires {
        sizeof(simd<std::uint64_t, 8, Arch>);
        sizeof(simd<std::uint8_t, 64, Arch>);
        sizeof(predicate<64, Arch>);
      })
  native_nodiscard consteval predicate<64, Arch> mask_vpshufbitqmb(
    predicate<64, Arch> mask,
    simd<std::uint64_t, 8, Arch> value,
    simd<std::uint8_t, 64, Arch> control) noexcept {
    return detail::x86_bitalg_constant::bitshuffle<predicate<64, Arch>>(
      value, control, mask.to_bitset());
  }

  template<isa<x86> Arch, class... Args>
  void vpopcntb(Args...) = delete;

  template<isa<x86> Arch, class... Args>
  void mask_vpopcntb(Args...) = delete;

  template<isa<x86> Arch, class... Args>
  void maskz_vpopcntb(Args...) = delete;

  template<isa<x86> Arch, class... Args>
  void vpopcntw(Args...) = delete;

  template<isa<x86> Arch, class... Args>
  void mask_vpopcntw(Args...) = delete;

  template<isa<x86> Arch, class... Args>
  void maskz_vpopcntw(Args...) = delete;

  template<isa<x86> Arch, class... Args>
  void vpshufbitqmb(Args...) = delete;

  template<isa<x86> Arch, class... Args>
  void mask_vpshufbitqmb(Args...) = delete;

}
#endif