native.arm.sha.ccm

// SPDX-License-Identifier: BSD-2-Clause OR Apache-2.0
module;
#include "native/isa_import.h"
#include "native/arm/detail/crypto_constant.h"
#include "native/arm/sha.h"
#include "native/targets.h"
export module native.arm.sha;
export import native.arm.features;
export import native.simd;
#if NATIVE_HOST_NEON || defined(NATIVE_DOXYGEN)
export namespace native {

  template<isa<arm> Arch> requires(Arch.has(arm_feature::sha1))
  native_nodiscard native_inline native_const native_target("sha2")
  constexpr simd<std::uint32_t, 4, Arch> sha1c(simd<std::uint32_t, 4, Arch> abcd, std::uint32_t e, simd<std::uint32_t, 4, Arch> wk) noexcept {
    if consteval { return detail::arm_constant::sha1_rounds<0>(abcd, e, wk); }
    else {
      auto result = detail::arm_sha::sha1c<Arch>(__builtin_bit_cast(uint32x4_t, abcd.to_native()), e, __builtin_bit_cast(uint32x4_t, wk.to_native()));
      return simd<std::uint32_t, 4, Arch>::from_native(__builtin_bit_cast(typename simd<std::uint32_t, 4, Arch>::native_type, result));
    }
  }

  template<isa<arm> Arch> requires(!Arch.has(arm_feature::sha1) && requires { sizeof(simd<std::uint32_t, 4, Arch>); })
  native_nodiscard consteval simd<std::uint32_t, 4, Arch> sha1c(simd<std::uint32_t, 4, Arch> abcd, std::uint32_t e, simd<std::uint32_t, 4, Arch> wk) noexcept {
    return detail::arm_constant::sha1_rounds<0>(abcd, e, wk);
  }

  template<isa<arm> Arch> requires(Arch.has(arm_feature::sha1))
  native_nodiscard native_inline native_const native_target("sha2")
  constexpr simd<std::uint32_t, 4, Arch> sha1p(simd<std::uint32_t, 4, Arch> abcd, std::uint32_t e, simd<std::uint32_t, 4, Arch> wk) noexcept {
    if consteval { return detail::arm_constant::sha1_rounds<1>(abcd, e, wk); }
    else {
      auto result = detail::arm_sha::sha1p<Arch>(__builtin_bit_cast(uint32x4_t, abcd.to_native()), e, __builtin_bit_cast(uint32x4_t, wk.to_native()));
      return simd<std::uint32_t, 4, Arch>::from_native(__builtin_bit_cast(typename simd<std::uint32_t, 4, Arch>::native_type, result));
    }
  }

  template<isa<arm> Arch> requires(!Arch.has(arm_feature::sha1) && requires { sizeof(simd<std::uint32_t, 4, Arch>); })
  native_nodiscard consteval simd<std::uint32_t, 4, Arch> sha1p(simd<std::uint32_t, 4, Arch> abcd, std::uint32_t e, simd<std::uint32_t, 4, Arch> wk) noexcept {
    return detail::arm_constant::sha1_rounds<1>(abcd, e, wk);
  }

  template<isa<arm> Arch> requires(Arch.has(arm_feature::sha1))
  native_nodiscard native_inline native_const native_target("sha2")
  constexpr simd<std::uint32_t, 4, Arch> sha1m(simd<std::uint32_t, 4, Arch> abcd, std::uint32_t e, simd<std::uint32_t, 4, Arch> wk) noexcept {
    if consteval { return detail::arm_constant::sha1_rounds<2>(abcd, e, wk); }
    else {
      auto result = detail::arm_sha::sha1m<Arch>(__builtin_bit_cast(uint32x4_t, abcd.to_native()), e, __builtin_bit_cast(uint32x4_t, wk.to_native()));
      return simd<std::uint32_t, 4, Arch>::from_native(__builtin_bit_cast(typename simd<std::uint32_t, 4, Arch>::native_type, result));
    }
  }

  template<isa<arm> Arch> requires(!Arch.has(arm_feature::sha1) && requires { sizeof(simd<std::uint32_t, 4, Arch>); })
  native_nodiscard consteval simd<std::uint32_t, 4, Arch> sha1m(simd<std::uint32_t, 4, Arch> abcd, std::uint32_t e, simd<std::uint32_t, 4, Arch> wk) noexcept {
    return detail::arm_constant::sha1_rounds<2>(abcd, e, wk);
  }

  template<isa<arm> Arch=NATIVE_BASELINE> requires(Arch.has(arm_feature::sha1))
  native_nodiscard native_inline native_const native_target("sha2")
  constexpr std::uint32_t sha1h(std::uint32_t a) noexcept {
    if consteval { return (a>>2)|(a<<30); }
    else { return detail::arm_sha::sha1h<Arch>(a); }
  }

  template<isa<arm> Arch=NATIVE_BASELINE> requires(!Arch.has(arm_feature::sha1))
  native_nodiscard consteval std::uint32_t sha1h(std::uint32_t a) noexcept {
    return (a>>2)|(a<<30);
  }

  template<isa<arm> Arch> requires(Arch.has(arm_feature::sha1))
  native_nodiscard native_inline native_const native_target("sha2")
  constexpr simd<std::uint32_t, 4, Arch> sha1su0(simd<std::uint32_t, 4, Arch> w0_3, simd<std::uint32_t, 4, Arch> w4_7, simd<std::uint32_t, 4, Arch> w8_11) noexcept {
    if consteval { return detail::arm_constant::sha1su0(w0_3, w4_7, w8_11); }
    else {
      auto result = detail::arm_sha::sha1su0<Arch>(__builtin_bit_cast(uint32x4_t, w0_3.to_native()), __builtin_bit_cast(uint32x4_t, w4_7.to_native()), __builtin_bit_cast(uint32x4_t, w8_11.to_native()));
      return simd<std::uint32_t, 4, Arch>::from_native(__builtin_bit_cast(typename simd<std::uint32_t, 4, Arch>::native_type, result));
    }
  }

  template<isa<arm> Arch> requires(!Arch.has(arm_feature::sha1) && requires { sizeof(simd<std::uint32_t, 4, Arch>); })
  native_nodiscard consteval simd<std::uint32_t, 4, Arch> sha1su0(simd<std::uint32_t, 4, Arch> w0_3, simd<std::uint32_t, 4, Arch> w4_7, simd<std::uint32_t, 4, Arch> w8_11) noexcept {
    return detail::arm_constant::sha1su0(w0_3, w4_7, w8_11);
  }

  template<isa<arm> Arch> requires(Arch.has(arm_feature::sha1))
  native_nodiscard native_inline native_const native_target("sha2")
  constexpr simd<std::uint32_t, 4, Arch> sha1su1(simd<std::uint32_t, 4, Arch> partial, simd<std::uint32_t, 4, Arch> w12_15) noexcept {
    if consteval { return detail::arm_constant::sha1su1(partial, w12_15); }
    else {
      auto result = detail::arm_sha::sha1su1<Arch>(__builtin_bit_cast(uint32x4_t, partial.to_native()), __builtin_bit_cast(uint32x4_t, w12_15.to_native()));
      return simd<std::uint32_t, 4, Arch>::from_native(__builtin_bit_cast(typename simd<std::uint32_t, 4, Arch>::native_type, result));
    }
  }

  template<isa<arm> Arch> requires(!Arch.has(arm_feature::sha1) && requires { sizeof(simd<std::uint32_t, 4, Arch>); })
  native_nodiscard consteval simd<std::uint32_t, 4, Arch> sha1su1(simd<std::uint32_t, 4, Arch> partial, simd<std::uint32_t, 4, Arch> w12_15) noexcept {
    return detail::arm_constant::sha1su1(partial, w12_15);
  }

  template<isa<arm> Arch> requires(Arch.has(arm_feature::sha2))
  native_nodiscard native_inline native_const native_target("sha2")
  constexpr simd<std::uint32_t, 4, Arch> sha256h(simd<std::uint32_t, 4, Arch> abcd, simd<std::uint32_t, 4, Arch> efgh, simd<std::uint32_t, 4, Arch> wk) noexcept {
    if consteval { return detail::arm_constant::sha256_rounds<false>(abcd, efgh, wk); }
    else {
      auto result = detail::arm_sha::sha256h<Arch>(__builtin_bit_cast(uint32x4_t, abcd.to_native()), __builtin_bit_cast(uint32x4_t, efgh.to_native()), __builtin_bit_cast(uint32x4_t, wk.to_native()));
      return simd<std::uint32_t, 4, Arch>::from_native(__builtin_bit_cast(typename simd<std::uint32_t, 4, Arch>::native_type, result));
    }
  }

  template<isa<arm> Arch> requires(!Arch.has(arm_feature::sha2) && requires { sizeof(simd<std::uint32_t, 4, Arch>); })
  native_nodiscard consteval simd<std::uint32_t, 4, Arch> sha256h(simd<std::uint32_t, 4, Arch> abcd, simd<std::uint32_t, 4, Arch> efgh, simd<std::uint32_t, 4, Arch> wk) noexcept {
    return detail::arm_constant::sha256_rounds<false>(abcd, efgh, wk);
  }

  template<isa<arm> Arch> requires(Arch.has(arm_feature::sha2))
  native_nodiscard native_inline native_const native_target("sha2")
  constexpr simd<std::uint32_t, 4, Arch> sha256h2(simd<std::uint32_t, 4, Arch> efgh, simd<std::uint32_t, 4, Arch> abcd, simd<std::uint32_t, 4, Arch> wk) noexcept {
    if consteval { return detail::arm_constant::sha256_rounds<true>(efgh, abcd, wk); }
    else {
      auto result = detail::arm_sha::sha256h2<Arch>(__builtin_bit_cast(uint32x4_t, efgh.to_native()), __builtin_bit_cast(uint32x4_t, abcd.to_native()), __builtin_bit_cast(uint32x4_t, wk.to_native()));
      return simd<std::uint32_t, 4, Arch>::from_native(__builtin_bit_cast(typename simd<std::uint32_t, 4, Arch>::native_type, result));
    }
  }

  template<isa<arm> Arch> requires(!Arch.has(arm_feature::sha2) && requires { sizeof(simd<std::uint32_t, 4, Arch>); })
  native_nodiscard consteval simd<std::uint32_t, 4, Arch> sha256h2(simd<std::uint32_t, 4, Arch> efgh, simd<std::uint32_t, 4, Arch> abcd, simd<std::uint32_t, 4, Arch> wk) noexcept {
    return detail::arm_constant::sha256_rounds<true>(efgh, abcd, wk);
  }

  template<isa<arm> Arch> requires(Arch.has(arm_feature::sha2))
  native_nodiscard native_inline native_const native_target("sha2")
  constexpr simd<std::uint32_t, 4, Arch> sha256su0(simd<std::uint32_t, 4, Arch> w0_3, simd<std::uint32_t, 4, Arch> w4_7) noexcept {
    if consteval { return detail::arm_constant::sha256su0(w0_3, w4_7); }
    else {
      auto result = detail::arm_sha::sha256su0<Arch>(__builtin_bit_cast(uint32x4_t, w0_3.to_native()), __builtin_bit_cast(uint32x4_t, w4_7.to_native()));
      return simd<std::uint32_t, 4, Arch>::from_native(__builtin_bit_cast(typename simd<std::uint32_t, 4, Arch>::native_type, result));
    }
  }

  template<isa<arm> Arch> requires(!Arch.has(arm_feature::sha2) && requires { sizeof(simd<std::uint32_t, 4, Arch>); })
  native_nodiscard consteval simd<std::uint32_t, 4, Arch> sha256su0(simd<std::uint32_t, 4, Arch> w0_3, simd<std::uint32_t, 4, Arch> w4_7) noexcept {
    return detail::arm_constant::sha256su0(w0_3, w4_7);
  }

  template<isa<arm> Arch> requires(Arch.has(arm_feature::sha2))
  native_nodiscard native_inline native_const native_target("sha2")
  constexpr simd<std::uint32_t, 4, Arch> sha256su1(simd<std::uint32_t, 4, Arch> partial, simd<std::uint32_t, 4, Arch> w8_11, simd<std::uint32_t, 4, Arch> w12_15) noexcept {
    if consteval { return detail::arm_constant::sha256su1(partial, w8_11, w12_15); }
    else {
      auto result = detail::arm_sha::sha256su1<Arch>(__builtin_bit_cast(uint32x4_t, partial.to_native()), __builtin_bit_cast(uint32x4_t, w8_11.to_native()), __builtin_bit_cast(uint32x4_t, w12_15.to_native()));
      return simd<std::uint32_t, 4, Arch>::from_native(__builtin_bit_cast(typename simd<std::uint32_t, 4, Arch>::native_type, result));
    }
  }

  template<isa<arm> Arch> requires(!Arch.has(arm_feature::sha2) && requires { sizeof(simd<std::uint32_t, 4, Arch>); })
  native_nodiscard consteval simd<std::uint32_t, 4, Arch> sha256su1(simd<std::uint32_t, 4, Arch> partial, simd<std::uint32_t, 4, Arch> w8_11, simd<std::uint32_t, 4, Arch> w12_15) noexcept {
    return detail::arm_constant::sha256su1(partial, w8_11, w12_15);
  }

  template<isa<arm> Arch> requires(Arch.has(arm_feature::sha512))
  native_nodiscard native_inline native_const native_target("sha3")
  constexpr simd<std::uint64_t, 2, Arch> sha512h(simd<std::uint64_t, 2, Arch> sum, simd<std::uint64_t, 2, Arch> fg, simd<std::uint64_t, 2, Arch> de) noexcept {
    if consteval { return detail::arm_constant::sha512h(sum, fg, de); }
    else {
      auto result = detail::arm_sha::sha512h<Arch>(__builtin_bit_cast(uint64x2_t, sum.to_native()), __builtin_bit_cast(uint64x2_t, fg.to_native()), __builtin_bit_cast(uint64x2_t, de.to_native()));
      return simd<std::uint64_t, 2, Arch>::from_native(__builtin_bit_cast(typename simd<std::uint64_t, 2, Arch>::native_type, result));
    }
  }

  template<isa<arm> Arch> requires(!Arch.has(arm_feature::sha512) && requires { sizeof(simd<std::uint64_t, 2, Arch>); })
  native_nodiscard consteval simd<std::uint64_t, 2, Arch> sha512h(simd<std::uint64_t, 2, Arch> sum, simd<std::uint64_t, 2, Arch> fg, simd<std::uint64_t, 2, Arch> de) noexcept {
    return detail::arm_constant::sha512h(sum, fg, de);
  }

  template<isa<arm> Arch> requires(Arch.has(arm_feature::sha512))
  native_nodiscard native_inline native_const native_target("sha3")
  constexpr simd<std::uint64_t, 2, Arch> sha512h2(simd<std::uint64_t, 2, Arch> sum_ab, simd<std::uint64_t, 2, Arch> c_, simd<std::uint64_t, 2, Arch> ab) noexcept {
    if consteval { return detail::arm_constant::sha512h2(sum_ab, c_, ab); }
    else {
      auto result = detail::arm_sha::sha512h2<Arch>(__builtin_bit_cast(uint64x2_t, sum_ab.to_native()), __builtin_bit_cast(uint64x2_t, c_.to_native()), __builtin_bit_cast(uint64x2_t, ab.to_native()));
      return simd<std::uint64_t, 2, Arch>::from_native(__builtin_bit_cast(typename simd<std::uint64_t, 2, Arch>::native_type, result));
    }
  }

  template<isa<arm> Arch> requires(!Arch.has(arm_feature::sha512) && requires { sizeof(simd<std::uint64_t, 2, Arch>); })
  native_nodiscard consteval simd<std::uint64_t, 2, Arch> sha512h2(simd<std::uint64_t, 2, Arch> sum_ab, simd<std::uint64_t, 2, Arch> c_, simd<std::uint64_t, 2, Arch> ab) noexcept {
    return detail::arm_constant::sha512h2(sum_ab, c_, ab);
  }

  template<isa<arm> Arch> requires(Arch.has(arm_feature::sha512))
  native_nodiscard native_inline native_const native_target("sha3")
  constexpr simd<std::uint64_t, 2, Arch> sha512su0(simd<std::uint64_t, 2, Arch> w0_1, simd<std::uint64_t, 2, Arch> w2_) noexcept {
    if consteval { return detail::arm_constant::sha512su0(w0_1, w2_); }
    else {
      auto result = detail::arm_sha::sha512su0<Arch>(__builtin_bit_cast(uint64x2_t, w0_1.to_native()), __builtin_bit_cast(uint64x2_t, w2_.to_native()));
      return simd<std::uint64_t, 2, Arch>::from_native(__builtin_bit_cast(typename simd<std::uint64_t, 2, Arch>::native_type, result));
    }
  }

  template<isa<arm> Arch> requires(!Arch.has(arm_feature::sha512) && requires { sizeof(simd<std::uint64_t, 2, Arch>); })
  native_nodiscard consteval simd<std::uint64_t, 2, Arch> sha512su0(simd<std::uint64_t, 2, Arch> w0_1, simd<std::uint64_t, 2, Arch> w2_) noexcept {
    return detail::arm_constant::sha512su0(w0_1, w2_);
  }

  template<isa<arm> Arch> requires(Arch.has(arm_feature::sha512))
  native_nodiscard native_inline native_const native_target("sha3")
  constexpr simd<std::uint64_t, 2, Arch> sha512su1(simd<std::uint64_t, 2, Arch> partial, simd<std::uint64_t, 2, Arch> w14_15, simd<std::uint64_t, 2, Arch> w9_10) noexcept {
    if consteval { return detail::arm_constant::sha512su1(partial, w14_15, w9_10); }
    else {
      auto result = detail::arm_sha::sha512su1<Arch>(__builtin_bit_cast(uint64x2_t, partial.to_native()), __builtin_bit_cast(uint64x2_t, w14_15.to_native()), __builtin_bit_cast(uint64x2_t, w9_10.to_native()));
      return simd<std::uint64_t, 2, Arch>::from_native(__builtin_bit_cast(typename simd<std::uint64_t, 2, Arch>::native_type, result));
    }
  }

  template<isa<arm> Arch> requires(!Arch.has(arm_feature::sha512) && requires { sizeof(simd<std::uint64_t, 2, Arch>); })
  native_nodiscard consteval simd<std::uint64_t, 2, Arch> sha512su1(simd<std::uint64_t, 2, Arch> partial, simd<std::uint64_t, 2, Arch> w14_15, simd<std::uint64_t, 2, Arch> w9_10) noexcept {
    return detail::arm_constant::sha512su1(partial, w14_15, w9_10);
  }

  template<isa<arm> Arch> requires(Arch.has(arm_feature::sha3))
  native_nodiscard native_inline native_const native_target("sha3")
  constexpr simd<std::uint8_t, 16, Arch> eor3(simd<std::uint8_t, 16, Arch> a, simd<std::uint8_t, 16, Arch> b, simd<std::uint8_t, 16, Arch> c) noexcept {
    if consteval { return detail::arm_constant::logical<false>(a, b, c); }
    else {
      auto result = detail::arm_sha::eor3<Arch>(__builtin_bit_cast(uint8x16_t, a.to_native()), __builtin_bit_cast(uint8x16_t, b.to_native()), __builtin_bit_cast(uint8x16_t, c.to_native()));
      return simd<std::uint8_t, 16, Arch>::from_native(__builtin_bit_cast(typename simd<std::uint8_t, 16, Arch>::native_type, result));
    }
  }

  template<isa<arm> Arch> requires(!Arch.has(arm_feature::sha3) && requires { sizeof(simd<std::uint8_t, 16, Arch>); })
  native_nodiscard consteval simd<std::uint8_t, 16, Arch> eor3(simd<std::uint8_t, 16, Arch> a, simd<std::uint8_t, 16, Arch> b, simd<std::uint8_t, 16, Arch> c) noexcept {
    return detail::arm_constant::logical<false>(a, b, c);
  }

  template<isa<arm> Arch> requires(Arch.has(arm_feature::sha3))
  native_nodiscard native_inline native_const native_target("sha3")
  constexpr simd<std::uint16_t, 8, Arch> eor3(simd<std::uint16_t, 8, Arch> a, simd<std::uint16_t, 8, Arch> b, simd<std::uint16_t, 8, Arch> c) noexcept {
    if consteval { return detail::arm_constant::logical<false>(a, b, c); }
    else {
      auto result = detail::arm_sha::eor3<Arch>(__builtin_bit_cast(uint16x8_t, a.to_native()), __builtin_bit_cast(uint16x8_t, b.to_native()), __builtin_bit_cast(uint16x8_t, c.to_native()));
      return simd<std::uint16_t, 8, Arch>::from_native(__builtin_bit_cast(typename simd<std::uint16_t, 8, Arch>::native_type, result));
    }
  }

  template<isa<arm> Arch> requires(!Arch.has(arm_feature::sha3) && requires { sizeof(simd<std::uint16_t, 8, Arch>); })
  native_nodiscard consteval simd<std::uint16_t, 8, Arch> eor3(simd<std::uint16_t, 8, Arch> a, simd<std::uint16_t, 8, Arch> b, simd<std::uint16_t, 8, Arch> c) noexcept {
    return detail::arm_constant::logical<false>(a, b, c);
  }

  template<isa<arm> Arch> requires(Arch.has(arm_feature::sha3))
  native_nodiscard native_inline native_const native_target("sha3")
  constexpr simd<std::uint32_t, 4, Arch> eor3(simd<std::uint32_t, 4, Arch> a, simd<std::uint32_t, 4, Arch> b, simd<std::uint32_t, 4, Arch> c) noexcept {
    if consteval { return detail::arm_constant::logical<false>(a, b, c); }
    else {
      auto result = detail::arm_sha::eor3<Arch>(__builtin_bit_cast(uint32x4_t, a.to_native()), __builtin_bit_cast(uint32x4_t, b.to_native()), __builtin_bit_cast(uint32x4_t, c.to_native()));
      return simd<std::uint32_t, 4, Arch>::from_native(__builtin_bit_cast(typename simd<std::uint32_t, 4, Arch>::native_type, result));
    }
  }

  template<isa<arm> Arch> requires(!Arch.has(arm_feature::sha3) && requires { sizeof(simd<std::uint32_t, 4, Arch>); })
  native_nodiscard consteval simd<std::uint32_t, 4, Arch> eor3(simd<std::uint32_t, 4, Arch> a, simd<std::uint32_t, 4, Arch> b, simd<std::uint32_t, 4, Arch> c) noexcept {
    return detail::arm_constant::logical<false>(a, b, c);
  }

  template<isa<arm> Arch> requires(Arch.has(arm_feature::sha3))
  native_nodiscard native_inline native_const native_target("sha3")
  constexpr simd<std::uint64_t, 2, Arch> eor3(simd<std::uint64_t, 2, Arch> a, simd<std::uint64_t, 2, Arch> b, simd<std::uint64_t, 2, Arch> c) noexcept {
    if consteval { return detail::arm_constant::logical<false>(a, b, c); }
    else {
      auto result = detail::arm_sha::eor3<Arch>(__builtin_bit_cast(uint64x2_t, a.to_native()), __builtin_bit_cast(uint64x2_t, b.to_native()), __builtin_bit_cast(uint64x2_t, c.to_native()));
      return simd<std::uint64_t, 2, Arch>::from_native(__builtin_bit_cast(typename simd<std::uint64_t, 2, Arch>::native_type, result));
    }
  }

  template<isa<arm> Arch> requires(!Arch.has(arm_feature::sha3) && requires { sizeof(simd<std::uint64_t, 2, Arch>); })
  native_nodiscard consteval simd<std::uint64_t, 2, Arch> eor3(simd<std::uint64_t, 2, Arch> a, simd<std::uint64_t, 2, Arch> b, simd<std::uint64_t, 2, Arch> c) noexcept {
    return detail::arm_constant::logical<false>(a, b, c);
  }

  template<isa<arm> Arch> requires(Arch.has(arm_feature::sha3))
  native_nodiscard native_inline native_const native_target("sha3")
  constexpr simd<std::int8_t, 16, Arch> eor3(simd<std::int8_t, 16, Arch> a, simd<std::int8_t, 16, Arch> b, simd<std::int8_t, 16, Arch> c) noexcept {
    if consteval { return detail::arm_constant::logical<false>(a, b, c); }
    else {
      auto result = detail::arm_sha::eor3<Arch>(__builtin_bit_cast(int8x16_t, a.to_native()), __builtin_bit_cast(int8x16_t, b.to_native()), __builtin_bit_cast(int8x16_t, c.to_native()));
      return simd<std::int8_t, 16, Arch>::from_native(__builtin_bit_cast(typename simd<std::int8_t, 16, Arch>::native_type, result));
    }
  }

  template<isa<arm> Arch> requires(!Arch.has(arm_feature::sha3) && requires { sizeof(simd<std::int8_t, 16, Arch>); })
  native_nodiscard consteval simd<std::int8_t, 16, Arch> eor3(simd<std::int8_t, 16, Arch> a, simd<std::int8_t, 16, Arch> b, simd<std::int8_t, 16, Arch> c) noexcept {
    return detail::arm_constant::logical<false>(a, b, c);
  }

  template<isa<arm> Arch> requires(Arch.has(arm_feature::sha3))
  native_nodiscard native_inline native_const native_target("sha3")
  constexpr simd<std::int16_t, 8, Arch> eor3(simd<std::int16_t, 8, Arch> a, simd<std::int16_t, 8, Arch> b, simd<std::int16_t, 8, Arch> c) noexcept {
    if consteval { return detail::arm_constant::logical<false>(a, b, c); }
    else {
      auto result = detail::arm_sha::eor3<Arch>(__builtin_bit_cast(int16x8_t, a.to_native()), __builtin_bit_cast(int16x8_t, b.to_native()), __builtin_bit_cast(int16x8_t, c.to_native()));
      return simd<std::int16_t, 8, Arch>::from_native(__builtin_bit_cast(typename simd<std::int16_t, 8, Arch>::native_type, result));
    }
  }

  template<isa<arm> Arch> requires(!Arch.has(arm_feature::sha3) && requires { sizeof(simd<std::int16_t, 8, Arch>); })
  native_nodiscard consteval simd<std::int16_t, 8, Arch> eor3(simd<std::int16_t, 8, Arch> a, simd<std::int16_t, 8, Arch> b, simd<std::int16_t, 8, Arch> c) noexcept {
    return detail::arm_constant::logical<false>(a, b, c);
  }

  template<isa<arm> Arch> requires(Arch.has(arm_feature::sha3))
  native_nodiscard native_inline native_const native_target("sha3")
  constexpr simd<std::int32_t, 4, Arch> eor3(simd<std::int32_t, 4, Arch> a, simd<std::int32_t, 4, Arch> b, simd<std::int32_t, 4, Arch> c) noexcept {
    if consteval { return detail::arm_constant::logical<false>(a, b, c); }
    else {
      auto result = detail::arm_sha::eor3<Arch>(__builtin_bit_cast(int32x4_t, a.to_native()), __builtin_bit_cast(int32x4_t, b.to_native()), __builtin_bit_cast(int32x4_t, c.to_native()));
      return simd<std::int32_t, 4, Arch>::from_native(__builtin_bit_cast(typename simd<std::int32_t, 4, Arch>::native_type, result));
    }
  }

  template<isa<arm> Arch> requires(!Arch.has(arm_feature::sha3) && requires { sizeof(simd<std::int32_t, 4, Arch>); })
  native_nodiscard consteval simd<std::int32_t, 4, Arch> eor3(simd<std::int32_t, 4, Arch> a, simd<std::int32_t, 4, Arch> b, simd<std::int32_t, 4, Arch> c) noexcept {
    return detail::arm_constant::logical<false>(a, b, c);
  }

  template<isa<arm> Arch> requires(Arch.has(arm_feature::sha3))
  native_nodiscard native_inline native_const native_target("sha3")
  constexpr simd<std::int64_t, 2, Arch> eor3(simd<std::int64_t, 2, Arch> a, simd<std::int64_t, 2, Arch> b, simd<std::int64_t, 2, Arch> c) noexcept {
    if consteval { return detail::arm_constant::logical<false>(a, b, c); }
    else {
      auto result = detail::arm_sha::eor3<Arch>(__builtin_bit_cast(int64x2_t, a.to_native()), __builtin_bit_cast(int64x2_t, b.to_native()), __builtin_bit_cast(int64x2_t, c.to_native()));
      return simd<std::int64_t, 2, Arch>::from_native(__builtin_bit_cast(typename simd<std::int64_t, 2, Arch>::native_type, result));
    }
  }

  template<isa<arm> Arch> requires(!Arch.has(arm_feature::sha3) && requires { sizeof(simd<std::int64_t, 2, Arch>); })
  native_nodiscard consteval simd<std::int64_t, 2, Arch> eor3(simd<std::int64_t, 2, Arch> a, simd<std::int64_t, 2, Arch> b, simd<std::int64_t, 2, Arch> c) noexcept {
    return detail::arm_constant::logical<false>(a, b, c);
  }

  template<isa<arm> Arch> requires(Arch.has(arm_feature::sha3))
  native_nodiscard native_inline native_const native_target("sha3")
  constexpr simd<std::uint8_t, 16, Arch> bcax(simd<std::uint8_t, 16, Arch> a, simd<std::uint8_t, 16, Arch> b, simd<std::uint8_t, 16, Arch> c) noexcept {
    if consteval { return detail::arm_constant::logical<true>(a, b, c); }
    else {
      auto result = detail::arm_sha::bcax<Arch>(__builtin_bit_cast(uint8x16_t, a.to_native()), __builtin_bit_cast(uint8x16_t, b.to_native()), __builtin_bit_cast(uint8x16_t, c.to_native()));
      return simd<std::uint8_t, 16, Arch>::from_native(__builtin_bit_cast(typename simd<std::uint8_t, 16, Arch>::native_type, result));
    }
  }

  template<isa<arm> Arch> requires(!Arch.has(arm_feature::sha3) && requires { sizeof(simd<std::uint8_t, 16, Arch>); })
  native_nodiscard consteval simd<std::uint8_t, 16, Arch> bcax(simd<std::uint8_t, 16, Arch> a, simd<std::uint8_t, 16, Arch> b, simd<std::uint8_t, 16, Arch> c) noexcept {
    return detail::arm_constant::logical<true>(a, b, c);
  }

  template<isa<arm> Arch> requires(Arch.has(arm_feature::sha3))
  native_nodiscard native_inline native_const native_target("sha3")
  constexpr simd<std::uint16_t, 8, Arch> bcax(simd<std::uint16_t, 8, Arch> a, simd<std::uint16_t, 8, Arch> b, simd<std::uint16_t, 8, Arch> c) noexcept {
    if consteval { return detail::arm_constant::logical<true>(a, b, c); }
    else {
      auto result = detail::arm_sha::bcax<Arch>(__builtin_bit_cast(uint16x8_t, a.to_native()), __builtin_bit_cast(uint16x8_t, b.to_native()), __builtin_bit_cast(uint16x8_t, c.to_native()));
      return simd<std::uint16_t, 8, Arch>::from_native(__builtin_bit_cast(typename simd<std::uint16_t, 8, Arch>::native_type, result));
    }
  }

  template<isa<arm> Arch> requires(!Arch.has(arm_feature::sha3) && requires { sizeof(simd<std::uint16_t, 8, Arch>); })
  native_nodiscard consteval simd<std::uint16_t, 8, Arch> bcax(simd<std::uint16_t, 8, Arch> a, simd<std::uint16_t, 8, Arch> b, simd<std::uint16_t, 8, Arch> c) noexcept {
    return detail::arm_constant::logical<true>(a, b, c);
  }

  template<isa<arm> Arch> requires(Arch.has(arm_feature::sha3))
  native_nodiscard native_inline native_const native_target("sha3")
  constexpr simd<std::uint32_t, 4, Arch> bcax(simd<std::uint32_t, 4, Arch> a, simd<std::uint32_t, 4, Arch> b, simd<std::uint32_t, 4, Arch> c) noexcept {
    if consteval { return detail::arm_constant::logical<true>(a, b, c); }
    else {
      auto result = detail::arm_sha::bcax<Arch>(__builtin_bit_cast(uint32x4_t, a.to_native()), __builtin_bit_cast(uint32x4_t, b.to_native()), __builtin_bit_cast(uint32x4_t, c.to_native()));
      return simd<std::uint32_t, 4, Arch>::from_native(__builtin_bit_cast(typename simd<std::uint32_t, 4, Arch>::native_type, result));
    }
  }

  template<isa<arm> Arch> requires(!Arch.has(arm_feature::sha3) && requires { sizeof(simd<std::uint32_t, 4, Arch>); })
  native_nodiscard consteval simd<std::uint32_t, 4, Arch> bcax(simd<std::uint32_t, 4, Arch> a, simd<std::uint32_t, 4, Arch> b, simd<std::uint32_t, 4, Arch> c) noexcept {
    return detail::arm_constant::logical<true>(a, b, c);
  }

  template<isa<arm> Arch> requires(Arch.has(arm_feature::sha3))
  native_nodiscard native_inline native_const native_target("sha3")
  constexpr simd<std::uint64_t, 2, Arch> bcax(simd<std::uint64_t, 2, Arch> a, simd<std::uint64_t, 2, Arch> b, simd<std::uint64_t, 2, Arch> c) noexcept {
    if consteval { return detail::arm_constant::logical<true>(a, b, c); }
    else {
      auto result = detail::arm_sha::bcax<Arch>(__builtin_bit_cast(uint64x2_t, a.to_native()), __builtin_bit_cast(uint64x2_t, b.to_native()), __builtin_bit_cast(uint64x2_t, c.to_native()));
      return simd<std::uint64_t, 2, Arch>::from_native(__builtin_bit_cast(typename simd<std::uint64_t, 2, Arch>::native_type, result));
    }
  }

  template<isa<arm> Arch> requires(!Arch.has(arm_feature::sha3) && requires { sizeof(simd<std::uint64_t, 2, Arch>); })
  native_nodiscard consteval simd<std::uint64_t, 2, Arch> bcax(simd<std::uint64_t, 2, Arch> a, simd<std::uint64_t, 2, Arch> b, simd<std::uint64_t, 2, Arch> c) noexcept {
    return detail::arm_constant::logical<true>(a, b, c);
  }

  template<isa<arm> Arch> requires(Arch.has(arm_feature::sha3))
  native_nodiscard native_inline native_const native_target("sha3")
  constexpr simd<std::int8_t, 16, Arch> bcax(simd<std::int8_t, 16, Arch> a, simd<std::int8_t, 16, Arch> b, simd<std::int8_t, 16, Arch> c) noexcept {
    if consteval { return detail::arm_constant::logical<true>(a, b, c); }
    else {
      auto result = detail::arm_sha::bcax<Arch>(__builtin_bit_cast(int8x16_t, a.to_native()), __builtin_bit_cast(int8x16_t, b.to_native()), __builtin_bit_cast(int8x16_t, c.to_native()));
      return simd<std::int8_t, 16, Arch>::from_native(__builtin_bit_cast(typename simd<std::int8_t, 16, Arch>::native_type, result));
    }
  }

  template<isa<arm> Arch> requires(!Arch.has(arm_feature::sha3) && requires { sizeof(simd<std::int8_t, 16, Arch>); })
  native_nodiscard consteval simd<std::int8_t, 16, Arch> bcax(simd<std::int8_t, 16, Arch> a, simd<std::int8_t, 16, Arch> b, simd<std::int8_t, 16, Arch> c) noexcept {
    return detail::arm_constant::logical<true>(a, b, c);
  }

  template<isa<arm> Arch> requires(Arch.has(arm_feature::sha3))
  native_nodiscard native_inline native_const native_target("sha3")
  constexpr simd<std::int16_t, 8, Arch> bcax(simd<std::int16_t, 8, Arch> a, simd<std::int16_t, 8, Arch> b, simd<std::int16_t, 8, Arch> c) noexcept {
    if consteval { return detail::arm_constant::logical<true>(a, b, c); }
    else {
      auto result = detail::arm_sha::bcax<Arch>(__builtin_bit_cast(int16x8_t, a.to_native()), __builtin_bit_cast(int16x8_t, b.to_native()), __builtin_bit_cast(int16x8_t, c.to_native()));
      return simd<std::int16_t, 8, Arch>::from_native(__builtin_bit_cast(typename simd<std::int16_t, 8, Arch>::native_type, result));
    }
  }

  template<isa<arm> Arch> requires(!Arch.has(arm_feature::sha3) && requires { sizeof(simd<std::int16_t, 8, Arch>); })
  native_nodiscard consteval simd<std::int16_t, 8, Arch> bcax(simd<std::int16_t, 8, Arch> a, simd<std::int16_t, 8, Arch> b, simd<std::int16_t, 8, Arch> c) noexcept {
    return detail::arm_constant::logical<true>(a, b, c);
  }

  template<isa<arm> Arch> requires(Arch.has(arm_feature::sha3))
  native_nodiscard native_inline native_const native_target("sha3")
  constexpr simd<std::int32_t, 4, Arch> bcax(simd<std::int32_t, 4, Arch> a, simd<std::int32_t, 4, Arch> b, simd<std::int32_t, 4, Arch> c) noexcept {
    if consteval { return detail::arm_constant::logical<true>(a, b, c); }
    else {
      auto result = detail::arm_sha::bcax<Arch>(__builtin_bit_cast(int32x4_t, a.to_native()), __builtin_bit_cast(int32x4_t, b.to_native()), __builtin_bit_cast(int32x4_t, c.to_native()));
      return simd<std::int32_t, 4, Arch>::from_native(__builtin_bit_cast(typename simd<std::int32_t, 4, Arch>::native_type, result));
    }
  }

  template<isa<arm> Arch> requires(!Arch.has(arm_feature::sha3) && requires { sizeof(simd<std::int32_t, 4, Arch>); })
  native_nodiscard consteval simd<std::int32_t, 4, Arch> bcax(simd<std::int32_t, 4, Arch> a, simd<std::int32_t, 4, Arch> b, simd<std::int32_t, 4, Arch> c) noexcept {
    return detail::arm_constant::logical<true>(a, b, c);
  }

  template<isa<arm> Arch> requires(Arch.has(arm_feature::sha3))
  native_nodiscard native_inline native_const native_target("sha3")
  constexpr simd<std::int64_t, 2, Arch> bcax(simd<std::int64_t, 2, Arch> a, simd<std::int64_t, 2, Arch> b, simd<std::int64_t, 2, Arch> c) noexcept {
    if consteval { return detail::arm_constant::logical<true>(a, b, c); }
    else {
      auto result = detail::arm_sha::bcax<Arch>(__builtin_bit_cast(int64x2_t, a.to_native()), __builtin_bit_cast(int64x2_t, b.to_native()), __builtin_bit_cast(int64x2_t, c.to_native()));
      return simd<std::int64_t, 2, Arch>::from_native(__builtin_bit_cast(typename simd<std::int64_t, 2, Arch>::native_type, result));
    }
  }

  template<isa<arm> Arch> requires(!Arch.has(arm_feature::sha3) && requires { sizeof(simd<std::int64_t, 2, Arch>); })
  native_nodiscard consteval simd<std::int64_t, 2, Arch> bcax(simd<std::int64_t, 2, Arch> a, simd<std::int64_t, 2, Arch> b, simd<std::int64_t, 2, Arch> c) noexcept {
    return detail::arm_constant::logical<true>(a, b, c);
  }

  template<isa<arm> Arch> requires(Arch.has(arm_feature::sha3))
  native_nodiscard native_inline native_const native_target("sha3")
  constexpr simd<std::uint64_t, 2, Arch> rax1(simd<std::uint64_t, 2, Arch> a, simd<std::uint64_t, 2, Arch> b) noexcept {
    if consteval { return detail::arm_constant::rax1(a, b); }
    else {
      auto result = detail::arm_sha::rax1<Arch>(__builtin_bit_cast(uint64x2_t, a.to_native()), __builtin_bit_cast(uint64x2_t, b.to_native()));
      return simd<std::uint64_t, 2, Arch>::from_native(__builtin_bit_cast(typename simd<std::uint64_t, 2, Arch>::native_type, result));
    }
  }

  template<isa<arm> Arch> requires(!Arch.has(arm_feature::sha3) && requires { sizeof(simd<std::uint64_t, 2, Arch>); })
  native_nodiscard consteval simd<std::uint64_t, 2, Arch> rax1(simd<std::uint64_t, 2, Arch> a, simd<std::uint64_t, 2, Arch> b) noexcept {
    return detail::arm_constant::rax1(a, b);
  }

  template<isa<arm> Arch, unsigned Rotate> requires(Arch.has(arm_feature::sha3) && Rotate < 64)
  native_nodiscard native_inline native_const native_target("sha3")
  constexpr simd<std::uint64_t, 2, Arch> xar(simd<std::uint64_t, 2, Arch> a, simd<std::uint64_t, 2, Arch> b) noexcept {
    if consteval { return detail::arm_constant::xar<Rotate>(a, b); }
    else {
      auto result = detail::arm_sha::xar<Arch, Rotate>(__builtin_bit_cast(uint64x2_t, a.to_native()), __builtin_bit_cast(uint64x2_t, b.to_native()));
      return simd<std::uint64_t, 2, Arch>::from_native(__builtin_bit_cast(typename simd<std::uint64_t, 2, Arch>::native_type, result));
    }
  }

  template<isa<arm> Arch, unsigned Rotate> requires(!Arch.has(arm_feature::sha3) && Rotate < 64 && requires { sizeof(simd<std::uint64_t, 2, Arch>); })
  native_nodiscard consteval simd<std::uint64_t, 2, Arch> xar(simd<std::uint64_t, 2, Arch> a, simd<std::uint64_t, 2, Arch> b) noexcept {
    return detail::arm_constant::xar<Rotate>(a, b);
  }
 
  // Require exact semantic shapes and a consistent feature tag.
  template<isa<arm> Arch, class... T> void sha1c(T...) = delete;

  template<isa<arm> Arch, class... T> void sha1p(T...) = delete;

  template<isa<arm> Arch, class... T> void sha1m(T...) = delete;

  template<isa<arm> Arch=NATIVE_BASELINE, class... T> void sha1h(T...) = delete;

  template<isa<arm> Arch, class... T> void sha1su0(T...) = delete;

  template<isa<arm> Arch, class... T> void sha1su1(T...) = delete;

  template<isa<arm> Arch, class... T> void sha256h(T...) = delete;

  template<isa<arm> Arch, class... T> void sha256h2(T...) = delete;

  template<isa<arm> Arch, class... T> void sha256su0(T...) = delete;

  template<isa<arm> Arch, class... T> void sha256su1(T...) = delete;

  template<isa<arm> Arch, class... T> void sha512h(T...) = delete;

  template<isa<arm> Arch, class... T> void sha512h2(T...) = delete;

  template<isa<arm> Arch, class... T> void sha512su0(T...) = delete;

  template<isa<arm> Arch, class... T> void sha512su1(T...) = delete;

  template<isa<arm> Arch, class... T> void eor3(T...) = delete;

  template<isa<arm> Arch, class... T> void bcax(T...) = delete;

  template<isa<arm> Arch, class... T> void rax1(T...) = delete;

  template<isa<arm> Arch, unsigned Rotate, class... T> void xar(T...) = delete;

}
#endif