Internal change.

PiperOrigin-RevId: 454629055
author: Tink Team <tink-dev@google.com> 2022-06-13 09:34:54 -0700
committer: Copybara-Service <copybara-worker@google.com> 2022-06-13 09:35:49 -0700
commit: 9db9e8a26801c90fb2d3d4799f978914242b596c (patch)
tree: 3a55cf234eb9bce15a95d4f522e3f1b2a7ba47cd /cc/experimental
parent: 5d81c95caec543d2fc00cb68bd1a971031ffea5b (diff)
download: tink-9db9e8a26801c90fb2d3d4799f978914242b596c.tar.gz
25 files changed, 1128 insertions, 1134 deletions
diff --git a/cc/experimental/pqcrypto/signature/dilithium_key_template.cc b/cc/experimental/pqcrypto/signature/dilithium_key_template.cc
index 26fc15b1e..adbaf9449 100644
--- a/cc/experimental/pqcrypto/signature/dilithium_key_template.cc
+++ b/cc/experimental/pqcrypto/signature/dilithium_key_template.cc
@@ -21,12 +21,12 @@
 #include "proto/tink.pb.h"
 
 extern "C" {
-#include "third_party/pqclean/crypto_sign/dilithium2/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/dilithium3/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/dilithium5/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/dilithium2aes/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/dilithium3aes/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/dilithium5aes/avx2/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium2/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium2aes/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium3/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium3aes/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium5/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium5aes/api.h"
 }
 
 namespace crypto {
@@ -60,42 +60,42 @@ KeyTemplate* NewDilithiumKeyTemplate(int32 key_size,
 
 const google::crypto::tink::KeyTemplate& Dilithium2KeyTemplate() {
   static const KeyTemplate* key_template =
-      NewDilithiumKeyTemplate(PQCLEAN_DILITHIUM2_AVX2_CRYPTO_SECRETKEYBYTES,
+      NewDilithiumKeyTemplate(PQCLEAN_DILITHIUM2_CRYPTO_SECRETKEYBYTES,
                               DilithiumSeedExpansion::SEED_EXPANSION_SHAKE);
   return *key_template;
 }
 
 const google::crypto::tink::KeyTemplate& Dilithium3KeyTemplate() {
   static const KeyTemplate* key_template =
-      NewDilithiumKeyTemplate(PQCLEAN_DILITHIUM3_AVX2_CRYPTO_SECRETKEYBYTES,
+      NewDilithiumKeyTemplate(PQCLEAN_DILITHIUM3_CRYPTO_SECRETKEYBYTES,
                               DilithiumSeedExpansion::SEED_EXPANSION_SHAKE);
   return *key_template;
 }
 
 const google::crypto::tink::KeyTemplate& Dilithium5KeyTemplate() {
   static const KeyTemplate* key_template =
-      NewDilithiumKeyTemplate(PQCLEAN_DILITHIUM5_AVX2_CRYPTO_SECRETKEYBYTES,
+      NewDilithiumKeyTemplate(PQCLEAN_DILITHIUM5_CRYPTO_SECRETKEYBYTES,
                               DilithiumSeedExpansion::SEED_EXPANSION_SHAKE);
   return *key_template;
 }
 
 const google::crypto::tink::KeyTemplate& Dilithium2AesKeyTemplate() {
   static const KeyTemplate* key_template =
-      NewDilithiumKeyTemplate(PQCLEAN_DILITHIUM2AES_AVX2_CRYPTO_SECRETKEYBYTES,
+      NewDilithiumKeyTemplate(PQCLEAN_DILITHIUM2AES_CRYPTO_SECRETKEYBYTES,
                               DilithiumSeedExpansion::SEED_EXPANSION_AES);
   return *key_template;
 }
 
 const google::crypto::tink::KeyTemplate& Dilithium3AesKeyTemplate() {
   static const KeyTemplate* key_template =
-      NewDilithiumKeyTemplate(PQCLEAN_DILITHIUM3AES_AVX2_CRYPTO_SECRETKEYBYTES,
+      NewDilithiumKeyTemplate(PQCLEAN_DILITHIUM3AES_CRYPTO_SECRETKEYBYTES,
                               DilithiumSeedExpansion::SEED_EXPANSION_AES);
   return *key_template;
 }
 
 const google::crypto::tink::KeyTemplate& Dilithium5AesKeyTemplate() {
   static const KeyTemplate* key_template =
-      NewDilithiumKeyTemplate(PQCLEAN_DILITHIUM5AES_AVX2_CRYPTO_SECRETKEYBYTES,
+      NewDilithiumKeyTemplate(PQCLEAN_DILITHIUM5AES_CRYPTO_SECRETKEYBYTES,
                               DilithiumSeedExpansion::SEED_EXPANSION_AES);
   return *key_template;
 }
diff --git a/cc/experimental/pqcrypto/signature/dilithium_key_template_test.cc b/cc/experimental/pqcrypto/signature/dilithium_key_template_test.cc
index 560b35b2e..fdc731d28 100644
--- a/cc/experimental/pqcrypto/signature/dilithium_key_template_test.cc
+++ b/cc/experimental/pqcrypto/signature/dilithium_key_template_test.cc
@@ -28,12 +28,12 @@
 #include "proto/tink.pb.h"
 
 extern "C" {
-#include "third_party/pqclean/crypto_sign/dilithium2/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/dilithium2aes/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/dilithium3/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/dilithium3aes/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/dilithium5/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/dilithium5aes/avx2/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium2/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium2aes/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium3/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium3aes/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium5/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium5aes/api.h"
 }
 
 namespace crypto {
@@ -107,22 +107,22 @@ TEST_P(DilithiumKeyTemplateTest, KeyManagerCompatibility) {
 INSTANTIATE_TEST_SUITE_P(
     DilithiumKeyTemplateTests, DilithiumKeyTemplateTest,
     testing::ValuesIn<DilithiumKeyTemplateTestCase>(
-        {{"Dilithium2", PQCLEAN_DILITHIUM2_AVX2_CRYPTO_SECRETKEYBYTES,
+        {{"Dilithium2", PQCLEAN_DILITHIUM2_CRYPTO_SECRETKEYBYTES,
           DilithiumSeedExpansion::SEED_EXPANSION_SHAKE,
           Dilithium2KeyTemplate()},
-         {"Dilithium3", PQCLEAN_DILITHIUM3_AVX2_CRYPTO_SECRETKEYBYTES,
+         {"Dilithium3", PQCLEAN_DILITHIUM3_CRYPTO_SECRETKEYBYTES,
           DilithiumSeedExpansion::SEED_EXPANSION_SHAKE,
           Dilithium3KeyTemplate()},
-         {"Dilithium5", PQCLEAN_DILITHIUM5_AVX2_CRYPTO_SECRETKEYBYTES,
+         {"Dilithium5", PQCLEAN_DILITHIUM5_CRYPTO_SECRETKEYBYTES,
           DilithiumSeedExpansion::SEED_EXPANSION_SHAKE,
           Dilithium5KeyTemplate()},
-         {"Dilithium2Aes", PQCLEAN_DILITHIUM2AES_AVX2_CRYPTO_SECRETKEYBYTES,
+         {"Dilithium2Aes", PQCLEAN_DILITHIUM2AES_CRYPTO_SECRETKEYBYTES,
           DilithiumSeedExpansion::SEED_EXPANSION_AES,
           Dilithium2AesKeyTemplate()},
-         {"Dilithium3Aes", PQCLEAN_DILITHIUM3AES_AVX2_CRYPTO_SECRETKEYBYTES,
+         {"Dilithium3Aes", PQCLEAN_DILITHIUM3AES_CRYPTO_SECRETKEYBYTES,
           DilithiumSeedExpansion::SEED_EXPANSION_AES,
           Dilithium3AesKeyTemplate()},
-         {"Dilithium5Aes", PQCLEAN_DILITHIUM5AES_AVX2_CRYPTO_SECRETKEYBYTES,
+         {"Dilithium5Aes", PQCLEAN_DILITHIUM5AES_CRYPTO_SECRETKEYBYTES,
           DilithiumSeedExpansion::SEED_EXPANSION_AES,
           Dilithium5AesKeyTemplate()}}),
     [](const testing::TestParamInfo<DilithiumKeyTemplateTest::ParamType>&
diff --git a/cc/experimental/pqcrypto/signature/dilithium_sign_key_manager.cc b/cc/experimental/pqcrypto/signature/dilithium_sign_key_manager.cc
index e79b286de..3acb09b90 100644
--- a/cc/experimental/pqcrypto/signature/dilithium_sign_key_manager.cc
+++ b/cc/experimental/pqcrypto/signature/dilithium_sign_key_manager.cc
@@ -34,9 +34,9 @@
 #include "tink/util/validation.h"
 
 extern "C" {
-#include "third_party/pqclean/crypto_sign/dilithium2/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/dilithium3/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/dilithium5/avx2/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium2/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium3/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium5/api.h"
 }
 
 namespace crypto {
@@ -96,12 +96,9 @@ Status DilithiumSignKeyManager::ValidateKey(
     const DilithiumPrivateKey& key) const {
   Status status = ValidateVersion(key.version(), get_version());
   if (!status.ok()) return status;
-  if (key.key_value().length() !=
-          PQCLEAN_DILITHIUM2_AVX2_CRYPTO_SECRETKEYBYTES &&
-      key.key_value().length() !=
-          PQCLEAN_DILITHIUM3_AVX2_CRYPTO_SECRETKEYBYTES &&
-      key.key_value().length() !=
-          PQCLEAN_DILITHIUM5_AVX2_CRYPTO_SECRETKEYBYTES) {
+  if (key.key_value().length() != PQCLEAN_DILITHIUM2_CRYPTO_SECRETKEYBYTES &&
+      key.key_value().length() != PQCLEAN_DILITHIUM3_CRYPTO_SECRETKEYBYTES &&
+      key.key_value().length() != PQCLEAN_DILITHIUM5_CRYPTO_SECRETKEYBYTES) {
     return Status(absl::StatusCode::kInvalidArgument,
                   "Invalid dilithium private key size.");
   }
diff --git a/cc/experimental/pqcrypto/signature/dilithium_sign_key_manager_test.cc b/cc/experimental/pqcrypto/signature/dilithium_sign_key_manager_test.cc
index c01fcb5e8..a67756d1c 100644
--- a/cc/experimental/pqcrypto/signature/dilithium_sign_key_manager_test.cc
+++ b/cc/experimental/pqcrypto/signature/dilithium_sign_key_manager_test.cc
@@ -33,12 +33,12 @@
 #include "tink/util/test_matchers.h"
 
 extern "C" {
-#include "third_party/pqclean/crypto_sign/dilithium2/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/dilithium2aes/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/dilithium3/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/dilithium3aes/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/dilithium5/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/dilithium5aes/avx2/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium2/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium2aes/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium3/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium3aes/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium5/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium5aes/api.h"
 }
 
 namespace crypto {
@@ -245,23 +245,23 @@ TEST_P(DilithiumSignKeyManagerTest, CreateDifferentKey) {
 INSTANTIATE_TEST_SUITE_P(
     DilithiumSignKeyManagerTests, DilithiumSignKeyManagerTest,
     testing::ValuesIn<DilithiumTestCase>({
-        {"Dilithium2", PQCLEAN_DILITHIUM2_AVX2_CRYPTO_SECRETKEYBYTES,
-         PQCLEAN_DILITHIUM2_AVX2_CRYPTO_PUBLICKEYBYTES,
+        {"Dilithium2", PQCLEAN_DILITHIUM2_CRYPTO_SECRETKEYBYTES,
+         PQCLEAN_DILITHIUM2_CRYPTO_PUBLICKEYBYTES,
          DilithiumSeedExpansion::SEED_EXPANSION_SHAKE},
-        {"Dilithium3", PQCLEAN_DILITHIUM3_AVX2_CRYPTO_SECRETKEYBYTES,
-         PQCLEAN_DILITHIUM3_AVX2_CRYPTO_PUBLICKEYBYTES,
+        {"Dilithium3", PQCLEAN_DILITHIUM3_CRYPTO_SECRETKEYBYTES,
+         PQCLEAN_DILITHIUM3_CRYPTO_PUBLICKEYBYTES,
          DilithiumSeedExpansion::SEED_EXPANSION_SHAKE},
-        {"Dilithium5", PQCLEAN_DILITHIUM5_AVX2_CRYPTO_SECRETKEYBYTES,
-         PQCLEAN_DILITHIUM5_AVX2_CRYPTO_PUBLICKEYBYTES,
+        {"Dilithium5", PQCLEAN_DILITHIUM5_CRYPTO_SECRETKEYBYTES,
+         PQCLEAN_DILITHIUM5_CRYPTO_PUBLICKEYBYTES,
          DilithiumSeedExpansion::SEED_EXPANSION_SHAKE},
-        {"Dilithium2Aes", PQCLEAN_DILITHIUM2AES_AVX2_CRYPTO_SECRETKEYBYTES,
-         PQCLEAN_DILITHIUM2AES_AVX2_CRYPTO_PUBLICKEYBYTES,
+        {"Dilithium2Aes", PQCLEAN_DILITHIUM2AES_CRYPTO_SECRETKEYBYTES,
+         PQCLEAN_DILITHIUM2AES_CRYPTO_PUBLICKEYBYTES,
          DilithiumSeedExpansion::SEED_EXPANSION_AES},
-        {"Dilithium3Aes", PQCLEAN_DILITHIUM3AES_AVX2_CRYPTO_SECRETKEYBYTES,
-         PQCLEAN_DILITHIUM3AES_AVX2_CRYPTO_PUBLICKEYBYTES,
+        {"Dilithium3Aes", PQCLEAN_DILITHIUM3AES_CRYPTO_SECRETKEYBYTES,
+         PQCLEAN_DILITHIUM3AES_CRYPTO_PUBLICKEYBYTES,
          DilithiumSeedExpansion::SEED_EXPANSION_AES},
-        {"Dilithium5Aes", PQCLEAN_DILITHIUM5AES_AVX2_CRYPTO_SECRETKEYBYTES,
-         PQCLEAN_DILITHIUM5AES_AVX2_CRYPTO_PUBLICKEYBYTES,
+        {"Dilithium5Aes", PQCLEAN_DILITHIUM5AES_CRYPTO_SECRETKEYBYTES,
+         PQCLEAN_DILITHIUM5AES_CRYPTO_PUBLICKEYBYTES,
          DilithiumSeedExpansion::SEED_EXPANSION_AES},
     }),
     [](const testing::TestParamInfo<DilithiumSignKeyManagerTest::ParamType>&
diff --git a/cc/experimental/pqcrypto/signature/dilithium_verify_key_manager.cc b/cc/experimental/pqcrypto/signature/dilithium_verify_key_manager.cc
index a0ae617ea..740e6f55c 100644
--- a/cc/experimental/pqcrypto/signature/dilithium_verify_key_manager.cc
+++ b/cc/experimental/pqcrypto/signature/dilithium_verify_key_manager.cc
@@ -33,9 +33,9 @@
 #include "tink/util/validation.h"
 
 extern "C" {
-#include "third_party/pqclean/crypto_sign/dilithium2/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/dilithium3/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/dilithium5/avx2/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium2/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium3/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium5/api.h"
 }
 
 namespace crypto {
@@ -67,12 +67,9 @@ Status DilithiumVerifyKeyManager::ValidateKey(
   Status status = ValidateVersion(key.version(), get_version());
   if (!status.ok()) return status;
 
-  if (key.key_value().length() !=
-          PQCLEAN_DILITHIUM2_AVX2_CRYPTO_PUBLICKEYBYTES &&
-      key.key_value().length() !=
-          PQCLEAN_DILITHIUM3_AVX2_CRYPTO_PUBLICKEYBYTES &&
-      key.key_value().length() !=
-          PQCLEAN_DILITHIUM5_AVX2_CRYPTO_PUBLICKEYBYTES) {
+  if (key.key_value().length() != PQCLEAN_DILITHIUM2_CRYPTO_PUBLICKEYBYTES &&
+      key.key_value().length() != PQCLEAN_DILITHIUM3_CRYPTO_PUBLICKEYBYTES &&
+      key.key_value().length() != PQCLEAN_DILITHIUM5_CRYPTO_PUBLICKEYBYTES) {
     return Status(absl::StatusCode::kInvalidArgument,
                   "Invalid dilithium public key size.");
   }
@@ -93,9 +90,9 @@ Status DilithiumVerifyKeyManager::ValidateParams(
   }
 
   switch (params.key_size()) {
-    case PQCLEAN_DILITHIUM2_AVX2_CRYPTO_SECRETKEYBYTES:
-    case PQCLEAN_DILITHIUM3_AVX2_CRYPTO_SECRETKEYBYTES:
-    case PQCLEAN_DILITHIUM5_AVX2_CRYPTO_SECRETKEYBYTES: {
+    case PQCLEAN_DILITHIUM2_CRYPTO_SECRETKEYBYTES:
+    case PQCLEAN_DILITHIUM3_CRYPTO_SECRETKEYBYTES:
+    case PQCLEAN_DILITHIUM5_CRYPTO_SECRETKEYBYTES: {
       break;
     }
     default: {
diff --git a/cc/experimental/pqcrypto/signature/dilithium_verify_key_manager_test.cc b/cc/experimental/pqcrypto/signature/dilithium_verify_key_manager_test.cc
index e87bd3ea7..3461bbaf0 100644
--- a/cc/experimental/pqcrypto/signature/dilithium_verify_key_manager_test.cc
+++ b/cc/experimental/pqcrypto/signature/dilithium_verify_key_manager_test.cc
@@ -34,12 +34,12 @@
 #include "tink/util/test_matchers.h"
 
 extern "C" {
-#include "third_party/pqclean/crypto_sign/dilithium2/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/dilithium2aes/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/dilithium3/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/dilithium3aes/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/dilithium5/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/dilithium5aes/avx2/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium2/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium2aes/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium3/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium3aes/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium5/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium5aes/api.h"
 }
 
 namespace crypto {
@@ -142,7 +142,7 @@ TEST_P(DilithiumVerifyKeyManagerTest, PublicKeyWrongKeyLength) {
       test_case.private_key_size, test_case.seed_expansion);
   ASSERT_THAT(public_key.status(), IsOk());
 
-  for (int keysize = 0; keysize < PQCLEAN_DILITHIUM2_AVX2_CRYPTO_PUBLICKEYBYTES;
+  for (int keysize = 0; keysize < PQCLEAN_DILITHIUM2_CRYPTO_PUBLICKEYBYTES;
        keysize++) {
     public_key->set_key_value(std::string(keysize, '@'));
     EXPECT_THAT(DilithiumVerifyKeyManager().ValidateKey(*public_key),
@@ -219,23 +219,23 @@ TEST_P(DilithiumVerifyKeyManagerTest, CreateDifferentPublicKey) {
 INSTANTIATE_TEST_SUITE_P(
     DilithiumVerifyKeyManagerTests, DilithiumVerifyKeyManagerTest,
     testing::ValuesIn<DilithiumTestCase>({
-        {"Dilithium2", PQCLEAN_DILITHIUM2_AVX2_CRYPTO_SECRETKEYBYTES,
-         PQCLEAN_DILITHIUM2_AVX2_CRYPTO_PUBLICKEYBYTES,
+        {"Dilithium2", PQCLEAN_DILITHIUM2_CRYPTO_SECRETKEYBYTES,
+         PQCLEAN_DILITHIUM2_CRYPTO_PUBLICKEYBYTES,
          DilithiumSeedExpansion::SEED_EXPANSION_SHAKE},
-        {"Dilithium3", PQCLEAN_DILITHIUM3_AVX2_CRYPTO_SECRETKEYBYTES,
-         PQCLEAN_DILITHIUM3_AVX2_CRYPTO_PUBLICKEYBYTES,
+        {"Dilithium3", PQCLEAN_DILITHIUM3_CRYPTO_SECRETKEYBYTES,
+         PQCLEAN_DILITHIUM3_CRYPTO_PUBLICKEYBYTES,
          DilithiumSeedExpansion::SEED_EXPANSION_SHAKE},
-        {"Dilithium5", PQCLEAN_DILITHIUM5_AVX2_CRYPTO_SECRETKEYBYTES,
-         PQCLEAN_DILITHIUM5_AVX2_CRYPTO_PUBLICKEYBYTES,
+        {"Dilithium5", PQCLEAN_DILITHIUM5_CRYPTO_SECRETKEYBYTES,
+         PQCLEAN_DILITHIUM5_CRYPTO_PUBLICKEYBYTES,
          DilithiumSeedExpansion::SEED_EXPANSION_SHAKE},
-        {"Dilithium2Aes", PQCLEAN_DILITHIUM2AES_AVX2_CRYPTO_SECRETKEYBYTES,
-         PQCLEAN_DILITHIUM2AES_AVX2_CRYPTO_PUBLICKEYBYTES,
+        {"Dilithium2Aes", PQCLEAN_DILITHIUM2AES_CRYPTO_SECRETKEYBYTES,
+         PQCLEAN_DILITHIUM2AES_CRYPTO_PUBLICKEYBYTES,
          DilithiumSeedExpansion::SEED_EXPANSION_AES},
-        {"Dilithium3Aes", PQCLEAN_DILITHIUM3AES_AVX2_CRYPTO_SECRETKEYBYTES,
-         PQCLEAN_DILITHIUM3AES_AVX2_CRYPTO_PUBLICKEYBYTES,
+        {"Dilithium3Aes", PQCLEAN_DILITHIUM3AES_CRYPTO_SECRETKEYBYTES,
+         PQCLEAN_DILITHIUM3AES_CRYPTO_PUBLICKEYBYTES,
          DilithiumSeedExpansion::SEED_EXPANSION_AES},
-        {"Dilithium5Aes", PQCLEAN_DILITHIUM5AES_AVX2_CRYPTO_SECRETKEYBYTES,
-         PQCLEAN_DILITHIUM5AES_AVX2_CRYPTO_PUBLICKEYBYTES,
+        {"Dilithium5Aes", PQCLEAN_DILITHIUM5AES_CRYPTO_SECRETKEYBYTES,
+         PQCLEAN_DILITHIUM5AES_CRYPTO_PUBLICKEYBYTES,
          DilithiumSeedExpansion::SEED_EXPANSION_AES},
     }),
     [](const testing::TestParamInfo<DilithiumVerifyKeyManagerTest::ParamType>&
diff --git a/cc/experimental/pqcrypto/signature/sphincs_key_template.cc b/cc/experimental/pqcrypto/signature/sphincs_key_template.cc
index b7d90f8c1..038b9c2c5 100644
--- a/cc/experimental/pqcrypto/signature/sphincs_key_template.cc
+++ b/cc/experimental/pqcrypto/signature/sphincs_key_template.cc
@@ -21,42 +21,42 @@
 #include "proto/tink.pb.h"
 
 extern "C" {
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-128f-robust/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-128f-simple/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-128s-robust/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-128s-simple/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-192f-robust/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-192f-simple/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-192s-robust/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-192s-simple/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-256f-robust/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-256f-simple/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-256s-robust/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-256s-simple/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-128f-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-128f-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-128s-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-128s-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-192f-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-192f-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-192s-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-192s-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-256f-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-256f-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-256s-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-256s-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-128f-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-128f-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-128s-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-128s-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-192f-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-192f-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-192s-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-192s-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-256f-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-256f-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-256s-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-256s-simple/avx2/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-128f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-128f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-128s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-128s-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-192f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-192f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-192s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-192s-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-256f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-256f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-256s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-256s-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-128f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-128f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-128s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-128s-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-192f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-192f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-192s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-192s-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-256f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-256f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-256s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-256s-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-128f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-128f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-128s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-128s-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-192f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-192f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-192s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-192s-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-256f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-256f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-256s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-256s-simple/api.h"
 }
 
 namespace crypto {
@@ -98,7 +98,7 @@ KeyTemplate* NewSphincsKeyTemplate(int32 private_key_size,
 const google::crypto::tink::KeyTemplate&
 Sphincs_Haraka_128_F_Robust_KeyTemplate() {
   static const KeyTemplate* key_template = NewSphincsKeyTemplate(
-      PQCLEAN_SPHINCSHARAKA128FROBUST_AESNI_CRYPTO_SECRETKEYBYTES,
+      PQCLEAN_SPHINCSHARAKA128FROBUST_CRYPTO_SECRETKEYBYTES,
       SphincsHashType::HARAKA, SphincsVariant::ROBUST,
       SphincsSignatureType::FAST_SIGNING);
   return *key_template;
@@ -107,7 +107,7 @@ Sphincs_Haraka_128_F_Robust_KeyTemplate() {
 const google::crypto::tink::KeyTemplate&
 Sphincs_Haraka_128_F_Simple_KeyTemplate() {
   static const KeyTemplate* key_template = NewSphincsKeyTemplate(
-      PQCLEAN_SPHINCSHARAKA128FSIMPLE_AESNI_CRYPTO_SECRETKEYBYTES,
+      PQCLEAN_SPHINCSHARAKA128FSIMPLE_CRYPTO_SECRETKEYBYTES,
       SphincsHashType::HARAKA, SphincsVariant::SIMPLE,
       SphincsSignatureType::FAST_SIGNING);
   return *key_template;
@@ -116,7 +116,7 @@ Sphincs_Haraka_128_F_Simple_KeyTemplate() {
 const google::crypto::tink::KeyTemplate&
 Sphincs_Haraka_128_S_Robust_KeyTemplate() {
   static const KeyTemplate* key_template = NewSphincsKeyTemplate(
-      PQCLEAN_SPHINCSHARAKA128SROBUST_AESNI_CRYPTO_SECRETKEYBYTES,
+      PQCLEAN_SPHINCSHARAKA128SROBUST_CRYPTO_SECRETKEYBYTES,
       SphincsHashType::HARAKA, SphincsVariant::ROBUST,
       SphincsSignatureType::SMALL_SIGNATURE);
   return *key_template;
@@ -125,7 +125,7 @@ Sphincs_Haraka_128_S_Robust_KeyTemplate() {
 const google::crypto::tink::KeyTemplate&
 Sphincs_Haraka_128_S_Simple_KeyTemplate() {
   static const KeyTemplate* key_template = NewSphincsKeyTemplate(
-      PQCLEAN_SPHINCSHARAKA128SSIMPLE_AESNI_CRYPTO_SECRETKEYBYTES,
+      PQCLEAN_SPHINCSHARAKA128SSIMPLE_CRYPTO_SECRETKEYBYTES,
       SphincsHashType::HARAKA, SphincsVariant::SIMPLE,
       SphincsSignatureType::SMALL_SIGNATURE);
   return *key_template;
@@ -134,7 +134,7 @@ Sphincs_Haraka_128_S_Simple_KeyTemplate() {
 const google::crypto::tink::KeyTemplate&
 Sphincs_Haraka_192_F_Robust_KeyTemplate() {
   static const KeyTemplate* key_template = NewSphincsKeyTemplate(
-      PQCLEAN_SPHINCSHARAKA192FROBUST_AESNI_CRYPTO_SECRETKEYBYTES,
+      PQCLEAN_SPHINCSHARAKA192FROBUST_CRYPTO_SECRETKEYBYTES,
       SphincsHashType::HARAKA, SphincsVariant::ROBUST,
       SphincsSignatureType::FAST_SIGNING);
   return *key_template;
@@ -143,7 +143,7 @@ Sphincs_Haraka_192_F_Robust_KeyTemplate() {
 const google::crypto::tink::KeyTemplate&
 Sphincs_Haraka_192_F_Simple_KeyTemplate() {
   static const KeyTemplate* key_template = NewSphincsKeyTemplate(
-      PQCLEAN_SPHINCSHARAKA192FSIMPLE_AESNI_CRYPTO_SECRETKEYBYTES,
+      PQCLEAN_SPHINCSHARAKA192FSIMPLE_CRYPTO_SECRETKEYBYTES,
       SphincsHashType::HARAKA, SphincsVariant::SIMPLE,
       SphincsSignatureType::FAST_SIGNING);
   return *key_template;
@@ -152,7 +152,7 @@ Sphincs_Haraka_192_F_Simple_KeyTemplate() {
 const google::crypto::tink::KeyTemplate&
 Sphincs_Haraka_192_S_Robust_KeyTemplate() {
   static const KeyTemplate* key_template = NewSphincsKeyTemplate(
-      PQCLEAN_SPHINCSHARAKA192SROBUST_AESNI_CRYPTO_SECRETKEYBYTES,
+      PQCLEAN_SPHINCSHARAKA192SROBUST_CRYPTO_SECRETKEYBYTES,
       SphincsHashType::HARAKA, SphincsVariant::ROBUST,
       SphincsSignatureType::SMALL_SIGNATURE);
   return *key_template;
@@ -161,7 +161,7 @@ Sphincs_Haraka_192_S_Robust_KeyTemplate() {
 const google::crypto::tink::KeyTemplate&
 Sphincs_Haraka_192_S_Simple_KeyTemplate() {
   static const KeyTemplate* key_template = NewSphincsKeyTemplate(
-      PQCLEAN_SPHINCSHARAKA192SSIMPLE_AESNI_CRYPTO_SECRETKEYBYTES,
+      PQCLEAN_SPHINCSHARAKA192SSIMPLE_CRYPTO_SECRETKEYBYTES,
       SphincsHashType::HARAKA, SphincsVariant::SIMPLE,
       SphincsSignatureType::SMALL_SIGNATURE);
   return *key_template;
@@ -170,7 +170,7 @@ Sphincs_Haraka_192_S_Simple_KeyTemplate() {
 const google::crypto::tink::KeyTemplate&
 Sphincs_Haraka_256_F_Robust_KeyTemplate() {
   static const KeyTemplate* key_template = NewSphincsKeyTemplate(
-      PQCLEAN_SPHINCSHARAKA256FROBUST_AESNI_CRYPTO_SECRETKEYBYTES,
+      PQCLEAN_SPHINCSHARAKA256FROBUST_CRYPTO_SECRETKEYBYTES,
       SphincsHashType::HARAKA, SphincsVariant::ROBUST,
       SphincsSignatureType::FAST_SIGNING);
   return *key_template;
@@ -179,7 +179,7 @@ Sphincs_Haraka_256_F_Robust_KeyTemplate() {
 const google::crypto::tink::KeyTemplate&
 Sphincs_Haraka_256_F_Simple_KeyTemplate() {
   static const KeyTemplate* key_template = NewSphincsKeyTemplate(
-      PQCLEAN_SPHINCSHARAKA256FSIMPLE_AESNI_CRYPTO_SECRETKEYBYTES,
+      PQCLEAN_SPHINCSHARAKA256FSIMPLE_CRYPTO_SECRETKEYBYTES,
       SphincsHashType::HARAKA, SphincsVariant::SIMPLE,
       SphincsSignatureType::FAST_SIGNING);
   return *key_template;
@@ -188,7 +188,7 @@ Sphincs_Haraka_256_F_Simple_KeyTemplate() {
 const google::crypto::tink::KeyTemplate&
 Sphincs_Haraka_256_S_Robust_KeyTemplate() {
   static const KeyTemplate* key_template = NewSphincsKeyTemplate(
-      PQCLEAN_SPHINCSHARAKA256SROBUST_AESNI_CRYPTO_SECRETKEYBYTES,
+      PQCLEAN_SPHINCSHARAKA256SROBUST_CRYPTO_SECRETKEYBYTES,
       SphincsHashType::HARAKA, SphincsVariant::ROBUST,
       SphincsSignatureType::SMALL_SIGNATURE);
   return *key_template;
@@ -197,7 +197,7 @@ Sphincs_Haraka_256_S_Robust_KeyTemplate() {
 const google::crypto::tink::KeyTemplate&
 Sphincs_Haraka_256_S_Simple_KeyTemplate() {
   static const KeyTemplate* key_template = NewSphincsKeyTemplate(
-      PQCLEAN_SPHINCSHARAKA256SSIMPLE_AESNI_CRYPTO_SECRETKEYBYTES,
+      PQCLEAN_SPHINCSHARAKA256SSIMPLE_CRYPTO_SECRETKEYBYTES,
       SphincsHashType::HARAKA, SphincsVariant::SIMPLE,
       SphincsSignatureType::SMALL_SIGNATURE);
   return *key_template;
@@ -207,7 +207,7 @@ Sphincs_Haraka_256_S_Simple_KeyTemplate() {
 const google::crypto::tink::KeyTemplate&
 Sphincs_Sha256_128_F_Robust_KeyTemplate() {
   static const KeyTemplate* key_template = NewSphincsKeyTemplate(
-      PQCLEAN_SPHINCSSHA256128FROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
+      PQCLEAN_SPHINCSSHA256128FROBUST_CRYPTO_SECRETKEYBYTES,
       SphincsHashType::SHA256, SphincsVariant::ROBUST,
       SphincsSignatureType::FAST_SIGNING);
   return *key_template;
@@ -216,7 +216,7 @@ Sphincs_Sha256_128_F_Robust_KeyTemplate() {
 const google::crypto::tink::KeyTemplate&
 Sphincs_Sha256_128_F_Simple_KeyTemplate() {
   static const KeyTemplate* key_template = NewSphincsKeyTemplate(
-      PQCLEAN_SPHINCSSHA256128FSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
+      PQCLEAN_SPHINCSSHA256128FSIMPLE_CRYPTO_SECRETKEYBYTES,
       SphincsHashType::SHA256, SphincsVariant::SIMPLE,
       SphincsSignatureType::FAST_SIGNING);
   return *key_template;
@@ -225,7 +225,7 @@ Sphincs_Sha256_128_F_Simple_KeyTemplate() {
 const google::crypto::tink::KeyTemplate&
 Sphincs_Sha256_128_S_Robust_KeyTemplate() {
   static const KeyTemplate* key_template = NewSphincsKeyTemplate(
-      PQCLEAN_SPHINCSSHA256128SROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
+      PQCLEAN_SPHINCSSHA256128SROBUST_CRYPTO_SECRETKEYBYTES,
       SphincsHashType::SHA256, SphincsVariant::ROBUST,
       SphincsSignatureType::SMALL_SIGNATURE);
   return *key_template;
@@ -234,7 +234,7 @@ Sphincs_Sha256_128_S_Robust_KeyTemplate() {
 const google::crypto::tink::KeyTemplate&
 Sphincs_Sha256_128_S_Simple_KeyTemplate() {
   static const KeyTemplate* key_template = NewSphincsKeyTemplate(
-      PQCLEAN_SPHINCSSHA256128SSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
+      PQCLEAN_SPHINCSSHA256128SSIMPLE_CRYPTO_SECRETKEYBYTES,
       SphincsHashType::SHA256, SphincsVariant::SIMPLE,
       SphincsSignatureType::SMALL_SIGNATURE);
   return *key_template;
@@ -243,7 +243,7 @@ Sphincs_Sha256_128_S_Simple_KeyTemplate() {
 const google::crypto::tink::KeyTemplate&
 Sphincs_Sha256_192_F_Robust_KeyTemplate() {
   static const KeyTemplate* key_template = NewSphincsKeyTemplate(
-      PQCLEAN_SPHINCSSHA256192FROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
+      PQCLEAN_SPHINCSSHA256192FROBUST_CRYPTO_SECRETKEYBYTES,
       SphincsHashType::SHA256, SphincsVariant::ROBUST,
       SphincsSignatureType::FAST_SIGNING);
   return *key_template;
@@ -252,7 +252,7 @@ Sphincs_Sha256_192_F_Robust_KeyTemplate() {
 const google::crypto::tink::KeyTemplate&
 Sphincs_Sha256_192_F_Simple_KeyTemplate() {
   static const KeyTemplate* key_template = NewSphincsKeyTemplate(
-      PQCLEAN_SPHINCSSHA256192FSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
+      PQCLEAN_SPHINCSSHA256192FSIMPLE_CRYPTO_SECRETKEYBYTES,
       SphincsHashType::SHA256, SphincsVariant::SIMPLE,
       SphincsSignatureType::FAST_SIGNING);
   return *key_template;
@@ -261,7 +261,7 @@ Sphincs_Sha256_192_F_Simple_KeyTemplate() {
 const google::crypto::tink::KeyTemplate&
 Sphincs_Sha256_192_S_Robust_KeyTemplate() {
   static const KeyTemplate* key_template = NewSphincsKeyTemplate(
-      PQCLEAN_SPHINCSSHA256192SROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
+      PQCLEAN_SPHINCSSHA256192SROBUST_CRYPTO_SECRETKEYBYTES,
       SphincsHashType::SHA256, SphincsVariant::ROBUST,
       SphincsSignatureType::SMALL_SIGNATURE);
   return *key_template;
@@ -270,7 +270,7 @@ Sphincs_Sha256_192_S_Robust_KeyTemplate() {
 const google::crypto::tink::KeyTemplate&
 Sphincs_Sha256_192_S_Simple_KeyTemplate() {
   static const KeyTemplate* key_template = NewSphincsKeyTemplate(
-      PQCLEAN_SPHINCSSHA256192SSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
+      PQCLEAN_SPHINCSSHA256192SSIMPLE_CRYPTO_SECRETKEYBYTES,
       SphincsHashType::SHA256, SphincsVariant::SIMPLE,
       SphincsSignatureType::SMALL_SIGNATURE);
   return *key_template;
@@ -279,7 +279,7 @@ Sphincs_Sha256_192_S_Simple_KeyTemplate() {
 const google::crypto::tink::KeyTemplate&
 Sphincs_Sha256_256_F_Robust_KeyTemplate() {
   static const KeyTemplate* key_template = NewSphincsKeyTemplate(
-      PQCLEAN_SPHINCSSHA256256FROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
+      PQCLEAN_SPHINCSSHA256256FROBUST_CRYPTO_SECRETKEYBYTES,
       SphincsHashType::SHA256, SphincsVariant::ROBUST,
       SphincsSignatureType::FAST_SIGNING);
   return *key_template;
@@ -288,7 +288,7 @@ Sphincs_Sha256_256_F_Robust_KeyTemplate() {
 const google::crypto::tink::KeyTemplate&
 Sphincs_Sha256_256_F_Simple_KeyTemplate() {
   static const KeyTemplate* key_template = NewSphincsKeyTemplate(
-      PQCLEAN_SPHINCSSHA256256FSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
+      PQCLEAN_SPHINCSSHA256256FSIMPLE_CRYPTO_SECRETKEYBYTES,
       SphincsHashType::SHA256, SphincsVariant::SIMPLE,
       SphincsSignatureType::FAST_SIGNING);
   return *key_template;
@@ -297,7 +297,7 @@ Sphincs_Sha256_256_F_Simple_KeyTemplate() {
 const google::crypto::tink::KeyTemplate&
 Sphincs_Sha256_256_S_Robust_KeyTemplate() {
   static const KeyTemplate* key_template = NewSphincsKeyTemplate(
-      PQCLEAN_SPHINCSSHA256256SROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
+      PQCLEAN_SPHINCSSHA256256SROBUST_CRYPTO_SECRETKEYBYTES,
       SphincsHashType::SHA256, SphincsVariant::ROBUST,
       SphincsSignatureType::SMALL_SIGNATURE);
   return *key_template;
@@ -306,7 +306,7 @@ Sphincs_Sha256_256_S_Robust_KeyTemplate() {
 const google::crypto::tink::KeyTemplate&
 Sphincs_Sha256_256_S_Simple_KeyTemplate() {
   static const KeyTemplate* key_template = NewSphincsKeyTemplate(
-      PQCLEAN_SPHINCSSHA256256SSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
+      PQCLEAN_SPHINCSSHA256256SSIMPLE_CRYPTO_SECRETKEYBYTES,
       SphincsHashType::SHA256, SphincsVariant::SIMPLE,
       SphincsSignatureType::SMALL_SIGNATURE);
   return *key_template;
@@ -316,7 +316,7 @@ Sphincs_Sha256_256_S_Simple_KeyTemplate() {
 const google::crypto::tink::KeyTemplate&
 Sphincs_Shake256_128_F_Robust_KeyTemplate() {
   static const KeyTemplate* key_template = NewSphincsKeyTemplate(
-      PQCLEAN_SPHINCSSHAKE256128FROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
+      PQCLEAN_SPHINCSSHAKE256128FROBUST_CRYPTO_SECRETKEYBYTES,
       SphincsHashType::SHAKE256, SphincsVariant::ROBUST,
       SphincsSignatureType::FAST_SIGNING);
   return *key_template;
@@ -325,7 +325,7 @@ Sphincs_Shake256_128_F_Robust_KeyTemplate() {
 const google::crypto::tink::KeyTemplate&
 Sphincs_Shake256_128_F_Simple_KeyTemplate() {
   static const KeyTemplate* key_template = NewSphincsKeyTemplate(
-      PQCLEAN_SPHINCSSHAKE256128FSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
+      PQCLEAN_SPHINCSSHAKE256128FSIMPLE_CRYPTO_SECRETKEYBYTES,
       SphincsHashType::SHAKE256, SphincsVariant::SIMPLE,
       SphincsSignatureType::FAST_SIGNING);
   return *key_template;
@@ -334,7 +334,7 @@ Sphincs_Shake256_128_F_Simple_KeyTemplate() {
 const google::crypto::tink::KeyTemplate&
 Sphincs_Shake256_128_S_Robust_KeyTemplate() {
   static const KeyTemplate* key_template = NewSphincsKeyTemplate(
-      PQCLEAN_SPHINCSSHAKE256128SROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
+      PQCLEAN_SPHINCSSHAKE256128SROBUST_CRYPTO_SECRETKEYBYTES,
       SphincsHashType::SHAKE256, SphincsVariant::ROBUST,
       SphincsSignatureType::SMALL_SIGNATURE);
   return *key_template;
@@ -343,7 +343,7 @@ Sphincs_Shake256_128_S_Robust_KeyTemplate() {
 const google::crypto::tink::KeyTemplate&
 Sphincs_Shake256_128_S_Simple_KeyTemplate() {
   static const KeyTemplate* key_template = NewSphincsKeyTemplate(
-      PQCLEAN_SPHINCSSHAKE256128SSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
+      PQCLEAN_SPHINCSSHAKE256128SSIMPLE_CRYPTO_SECRETKEYBYTES,
       SphincsHashType::SHAKE256, SphincsVariant::SIMPLE,
       SphincsSignatureType::SMALL_SIGNATURE);
   return *key_template;
@@ -352,7 +352,7 @@ Sphincs_Shake256_128_S_Simple_KeyTemplate() {
 const google::crypto::tink::KeyTemplate&
 Sphincs_Shake256_192_F_Robust_KeyTemplate() {
   static const KeyTemplate* key_template = NewSphincsKeyTemplate(
-      PQCLEAN_SPHINCSSHAKE256192FROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
+      PQCLEAN_SPHINCSSHAKE256192FROBUST_CRYPTO_SECRETKEYBYTES,
       SphincsHashType::SHAKE256, SphincsVariant::ROBUST,
       SphincsSignatureType::FAST_SIGNING);
   return *key_template;
@@ -361,7 +361,7 @@ Sphincs_Shake256_192_F_Robust_KeyTemplate() {
 const google::crypto::tink::KeyTemplate&
 Sphincs_Shake256_192_F_Simple_KeyTemplate() {
   static const KeyTemplate* key_template = NewSphincsKeyTemplate(
-      PQCLEAN_SPHINCSSHAKE256192FSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
+      PQCLEAN_SPHINCSSHAKE256192FSIMPLE_CRYPTO_SECRETKEYBYTES,
       SphincsHashType::SHAKE256, SphincsVariant::SIMPLE,
       SphincsSignatureType::FAST_SIGNING);
   return *key_template;
@@ -370,7 +370,7 @@ Sphincs_Shake256_192_F_Simple_KeyTemplate() {
 const google::crypto::tink::KeyTemplate&
 Sphincs_Shake256_192_S_Robust_KeyTemplate() {
   static const KeyTemplate* key_template = NewSphincsKeyTemplate(
-      PQCLEAN_SPHINCSSHAKE256192SROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
+      PQCLEAN_SPHINCSSHAKE256192SROBUST_CRYPTO_SECRETKEYBYTES,
       SphincsHashType::SHAKE256, SphincsVariant::ROBUST,
       SphincsSignatureType::SMALL_SIGNATURE);
   return *key_template;
@@ -379,7 +379,7 @@ Sphincs_Shake256_192_S_Robust_KeyTemplate() {
 const google::crypto::tink::KeyTemplate&
 Sphincs_Shake256_192_S_Simple_KeyTemplate() {
   static const KeyTemplate* key_template = NewSphincsKeyTemplate(
-      PQCLEAN_SPHINCSSHAKE256192SSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
+      PQCLEAN_SPHINCSSHAKE256192SSIMPLE_CRYPTO_SECRETKEYBYTES,
       SphincsHashType::SHAKE256, SphincsVariant::SIMPLE,
       SphincsSignatureType::SMALL_SIGNATURE);
   return *key_template;
@@ -388,7 +388,7 @@ Sphincs_Shake256_192_S_Simple_KeyTemplate() {
 const google::crypto::tink::KeyTemplate&
 Sphincs_Shake256_256_F_Robust_KeyTemplate() {
   static const KeyTemplate* key_template = NewSphincsKeyTemplate(
-      PQCLEAN_SPHINCSSHAKE256256FROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
+      PQCLEAN_SPHINCSSHAKE256256FROBUST_CRYPTO_SECRETKEYBYTES,
       SphincsHashType::SHAKE256, SphincsVariant::ROBUST,
       SphincsSignatureType::FAST_SIGNING);
   return *key_template;
@@ -397,7 +397,7 @@ Sphincs_Shake256_256_F_Robust_KeyTemplate() {
 const google::crypto::tink::KeyTemplate&
 Sphincs_Shake256_256_F_Simple_KeyTemplate() {
   static const KeyTemplate* key_template = NewSphincsKeyTemplate(
-      PQCLEAN_SPHINCSSHAKE256256FSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
+      PQCLEAN_SPHINCSSHAKE256256FSIMPLE_CRYPTO_SECRETKEYBYTES,
       SphincsHashType::SHAKE256, SphincsVariant::SIMPLE,
       SphincsSignatureType::FAST_SIGNING);
   return *key_template;
@@ -406,7 +406,7 @@ Sphincs_Shake256_256_F_Simple_KeyTemplate() {
 const google::crypto::tink::KeyTemplate&
 Sphincs_Shake256_256_S_Robust_KeyTemplate() {
   static const KeyTemplate* key_template = NewSphincsKeyTemplate(
-      PQCLEAN_SPHINCSSHAKE256256SROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
+      PQCLEAN_SPHINCSSHAKE256256SROBUST_CRYPTO_SECRETKEYBYTES,
       SphincsHashType::SHAKE256, SphincsVariant::ROBUST,
       SphincsSignatureType::SMALL_SIGNATURE);
   return *key_template;
@@ -415,7 +415,7 @@ Sphincs_Shake256_256_S_Robust_KeyTemplate() {
 const google::crypto::tink::KeyTemplate&
 Sphincs_Shake256_256_S_Simple_KeyTemplate() {
   static const KeyTemplate* key_template = NewSphincsKeyTemplate(
-      PQCLEAN_SPHINCSSHAKE256256SSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
+      PQCLEAN_SPHINCSSHAKE256256SSIMPLE_CRYPTO_SECRETKEYBYTES,
       SphincsHashType::SHAKE256, SphincsVariant::SIMPLE,
       SphincsSignatureType::SMALL_SIGNATURE);
   return *key_template;
diff --git a/cc/experimental/pqcrypto/signature/sphincs_key_template_test.cc b/cc/experimental/pqcrypto/signature/sphincs_key_template_test.cc
index d9a24f06b..6be0c20b5 100644
--- a/cc/experimental/pqcrypto/signature/sphincs_key_template_test.cc
+++ b/cc/experimental/pqcrypto/signature/sphincs_key_template_test.cc
@@ -28,42 +28,42 @@
 #include "proto/tink.pb.h"
 
 extern "C" {
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-128f-robust/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-128f-simple/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-128s-robust/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-128s-simple/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-192f-robust/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-192f-simple/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-192s-robust/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-192s-simple/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-256f-robust/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-256f-simple/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-256s-robust/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-256s-simple/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-128f-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-128f-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-128s-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-128s-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-192f-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-192f-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-192s-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-192s-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-256f-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-256f-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-256s-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-256s-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-128f-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-128f-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-128s-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-128s-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-192f-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-192f-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-192s-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-192s-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-256f-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-256f-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-256s-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-256s-simple/avx2/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-128f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-128f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-128s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-128s-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-192f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-192f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-192s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-192s-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-256f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-256f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-256s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-256s-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-128f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-128f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-128s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-128s-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-192f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-192f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-192s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-192s-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-256f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-256f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-256s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-256s-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-128f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-128f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-128s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-128s-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-192f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-192f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-192s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-192s-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-256f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-256f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-256s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-256s-simple/api.h"
 }
 
 namespace crypto {
@@ -140,155 +140,155 @@ INSTANTIATE_TEST_SUITE_P(
     testing::ValuesIn<SphincsTestCase>(
         {{"SPHINCSHARAKA128FROBUST", SphincsHashType::HARAKA,
           SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSHARAKA128FROBUST_AESNI_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA128FROBUST_CRYPTO_SECRETKEYBYTES,
           Sphincs_Haraka_128_F_Robust_KeyTemplate()},
          {"SPHINCSHARAKA128SROBUST", SphincsHashType::HARAKA,
           SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSHARAKA128SROBUST_AESNI_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA128SROBUST_CRYPTO_SECRETKEYBYTES,
           Sphincs_Haraka_128_S_Robust_KeyTemplate()},
          {"SPHINCSHARAKA128FSIMPLE", SphincsHashType::HARAKA,
           SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSHARAKA128FSIMPLE_AESNI_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA128FSIMPLE_CRYPTO_SECRETKEYBYTES,
           Sphincs_Haraka_128_F_Simple_KeyTemplate()},
          {"SPHINCSHARAKA128SSIMPLE", SphincsHashType::HARAKA,
           SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSHARAKA128SSIMPLE_AESNI_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA128SSIMPLE_CRYPTO_SECRETKEYBYTES,
           Sphincs_Haraka_128_S_Simple_KeyTemplate()},
 
          {"SPHINCSHARAKA192FROBUST", SphincsHashType::HARAKA,
           SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSHARAKA192FROBUST_AESNI_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA192FROBUST_CRYPTO_SECRETKEYBYTES,
           Sphincs_Haraka_192_F_Robust_KeyTemplate()},
          {"SPHINCSHARAKA192SROBUST", SphincsHashType::HARAKA,
           SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSHARAKA192SROBUST_AESNI_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA192SROBUST_CRYPTO_SECRETKEYBYTES,
           Sphincs_Haraka_192_S_Robust_KeyTemplate()},
          {"SPHINCSHARAKA192FSIMPLE", SphincsHashType::HARAKA,
           SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSHARAKA192FSIMPLE_AESNI_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA192FSIMPLE_CRYPTO_SECRETKEYBYTES,
           Sphincs_Haraka_192_F_Simple_KeyTemplate()},
          {"SPHINCSHARAKA192SSIMPLE", SphincsHashType::HARAKA,
           SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSHARAKA192SSIMPLE_AESNI_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA192SSIMPLE_CRYPTO_SECRETKEYBYTES,
           Sphincs_Haraka_192_S_Simple_KeyTemplate()},
 
          {"SPHINCSHARAKA256FROBUST", SphincsHashType::HARAKA,
           SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSHARAKA256FROBUST_AESNI_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA256FROBUST_CRYPTO_SECRETKEYBYTES,
           Sphincs_Haraka_256_F_Robust_KeyTemplate()},
          {"SPHINCSHARAKA256SROBUST", SphincsHashType::HARAKA,
           SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSHARAKA256SROBUST_AESNI_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA256SROBUST_CRYPTO_SECRETKEYBYTES,
           Sphincs_Haraka_256_S_Robust_KeyTemplate()},
          {"SPHINCSHARAKA256FSIMPLE", SphincsHashType::HARAKA,
           SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSHARAKA256FSIMPLE_AESNI_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA256FSIMPLE_CRYPTO_SECRETKEYBYTES,
           Sphincs_Haraka_256_F_Simple_KeyTemplate()},
          {"SPHINCSHARAKA256SSIMPLE", SphincsHashType::HARAKA,
           SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSHARAKA256SSIMPLE_AESNI_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA256SSIMPLE_CRYPTO_SECRETKEYBYTES,
           Sphincs_Haraka_256_S_Simple_KeyTemplate()},
 
          {"SPHINCSSHA256128FROBUST", SphincsHashType::SHA256,
           SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHA256128FROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256128FROBUST_CRYPTO_SECRETKEYBYTES,
           Sphincs_Sha256_128_F_Robust_KeyTemplate()},
          {"SPHINCSSHA256128SROBUST", SphincsHashType::SHA256,
           SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHA256128SROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256128SROBUST_CRYPTO_SECRETKEYBYTES,
           Sphincs_Sha256_128_S_Robust_KeyTemplate()},
          {"SPHINCSSHA256128FSIMPLE", SphincsHashType::SHA256,
           SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHA256128FSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256128FSIMPLE_CRYPTO_SECRETKEYBYTES,
           Sphincs_Sha256_128_F_Simple_KeyTemplate()},
          {"SPHINCSSHA256128SSIMPLE", SphincsHashType::SHA256,
           SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHA256128SSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256128SSIMPLE_CRYPTO_SECRETKEYBYTES,
           Sphincs_Sha256_128_S_Simple_KeyTemplate()},
 
          {"SPHINCSSHA256192FROBUST", SphincsHashType::SHA256,
           SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHA256192FROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256192FROBUST_CRYPTO_SECRETKEYBYTES,
           Sphincs_Sha256_192_F_Robust_KeyTemplate()},
          {"SPHINCSSHA256192SROBUST", SphincsHashType::SHA256,
           SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHA256192SROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256192SROBUST_CRYPTO_SECRETKEYBYTES,
           Sphincs_Sha256_192_S_Robust_KeyTemplate()},
          {"SPHINCSSHA256192FSIMPLE", SphincsHashType::SHA256,
           SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHA256192FSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256192FSIMPLE_CRYPTO_SECRETKEYBYTES,
           Sphincs_Sha256_192_F_Simple_KeyTemplate()},
          {"SPHINCSSHA256192SSIMPLE", SphincsHashType::SHA256,
           SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHA256192SSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256192SSIMPLE_CRYPTO_SECRETKEYBYTES,
           Sphincs_Sha256_192_S_Simple_KeyTemplate()},
 
          {"SPHINCSSHA256256FROBUST", SphincsHashType::SHA256,
           SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHA256256FROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256256FROBUST_CRYPTO_SECRETKEYBYTES,
           Sphincs_Sha256_256_F_Robust_KeyTemplate()},
          {"SPHINCSSHA256256SROBUST", SphincsHashType::SHA256,
           SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHA256256SROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256256SROBUST_CRYPTO_SECRETKEYBYTES,
           Sphincs_Sha256_256_S_Robust_KeyTemplate()},
          {"SPHINCSSHA256256FSIMPLE", SphincsHashType::SHA256,
           SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHA256256FSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256256FSIMPLE_CRYPTO_SECRETKEYBYTES,
           Sphincs_Sha256_256_F_Simple_KeyTemplate()},
          {"SPHINCSSHA256256SSIMPLE", SphincsHashType::SHA256,
           SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHA256256SSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256256SSIMPLE_CRYPTO_SECRETKEYBYTES,
           Sphincs_Sha256_256_S_Simple_KeyTemplate()},
 
          {"SPHINCSSHAKE256128FROBUST", SphincsHashType::SHAKE256,
           SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHAKE256128FROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256128FROBUST_CRYPTO_SECRETKEYBYTES,
           Sphincs_Shake256_128_F_Robust_KeyTemplate()},
          {"SPHINCSSHAKE256128SROBUST", SphincsHashType::SHAKE256,
           SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHAKE256128SROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256128SROBUST_CRYPTO_SECRETKEYBYTES,
           Sphincs_Shake256_128_S_Robust_KeyTemplate()},
          {"SPHINCSSHAKE256128FSIMPLE", SphincsHashType::SHAKE256,
           SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHAKE256128FSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256128FSIMPLE_CRYPTO_SECRETKEYBYTES,
           Sphincs_Shake256_128_F_Simple_KeyTemplate()},
          {"SPHINCSSHAKE256128SSIMPLE", SphincsHashType::SHAKE256,
           SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHAKE256128SSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256128SSIMPLE_CRYPTO_SECRETKEYBYTES,
           Sphincs_Shake256_128_S_Simple_KeyTemplate()},
 
          {"SPHINCSSHAKE256192FROBUST", SphincsHashType::SHAKE256,
           SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHAKE256192FROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256192FROBUST_CRYPTO_SECRETKEYBYTES,
           Sphincs_Shake256_192_F_Robust_KeyTemplate()},
          {"SPHINCSSHAKE256192SROBUST", SphincsHashType::SHAKE256,
           SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHAKE256192SROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256192SROBUST_CRYPTO_SECRETKEYBYTES,
           Sphincs_Shake256_192_S_Robust_KeyTemplate()},
          {"SPHINCSSHAKE256192FSIMPLE", SphincsHashType::SHAKE256,
           SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHAKE256192FSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256192FSIMPLE_CRYPTO_SECRETKEYBYTES,
           Sphincs_Shake256_192_F_Simple_KeyTemplate()},
          {"SPHINCSSHAKE256192SSIMPLE", SphincsHashType::SHAKE256,
           SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHAKE256192SSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256192SSIMPLE_CRYPTO_SECRETKEYBYTES,
           Sphincs_Shake256_192_S_Simple_KeyTemplate()},
 
          {"SPHINCSSHAKE256256FROBUST", SphincsHashType::SHAKE256,
           SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHAKE256256FROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256256FROBUST_CRYPTO_SECRETKEYBYTES,
           Sphincs_Shake256_256_F_Robust_KeyTemplate()},
          {"SPHINCSSHAKE256256SROBUST", SphincsHashType::SHAKE256,
           SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHAKE256256SROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256256SROBUST_CRYPTO_SECRETKEYBYTES,
           Sphincs_Shake256_256_S_Robust_KeyTemplate()},
          {"SPHINCSSHAKE256256FSIMPLE", SphincsHashType::SHAKE256,
           SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHAKE256256FSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256256FSIMPLE_CRYPTO_SECRETKEYBYTES,
           Sphincs_Shake256_256_F_Simple_KeyTemplate()},
          {"SPHINCSSHAKE256256SSIMPLE", SphincsHashType::SHAKE256,
           SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHAKE256256SSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256256SSIMPLE_CRYPTO_SECRETKEYBYTES,
           Sphincs_Shake256_256_S_Simple_KeyTemplate()}}),
     [](const testing::TestParamInfo<SphincsKeyTemplateTest::ParamType>& info) {
       return info.param.test_name;
diff --git a/cc/experimental/pqcrypto/signature/sphincs_sign_key_manager_test.cc b/cc/experimental/pqcrypto/signature/sphincs_sign_key_manager_test.cc
index cf76669eb..249b5e603 100644
--- a/cc/experimental/pqcrypto/signature/sphincs_sign_key_manager_test.cc
+++ b/cc/experimental/pqcrypto/signature/sphincs_sign_key_manager_test.cc
@@ -34,42 +34,42 @@
 #include "tink/util/test_matchers.h"
 
 extern "C" {
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-128f-robust/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-128f-simple/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-128s-robust/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-128s-simple/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-192f-robust/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-192f-simple/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-192s-robust/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-192s-simple/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-256f-robust/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-256f-simple/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-256s-robust/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-256s-simple/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-128f-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-128f-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-128s-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-128s-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-192f-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-192f-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-192s-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-192s-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-256f-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-256f-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-256s-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-256s-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-128f-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-128f-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-128s-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-128s-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-192f-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-192f-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-192s-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-192s-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-256f-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-256f-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-256s-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-256s-simple/avx2/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-128f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-128f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-128s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-128s-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-192f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-192f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-192s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-192s-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-256f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-256f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-256s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-256s-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-128f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-128f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-128s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-128s-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-192f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-192f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-192s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-192s-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-256f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-256f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-256s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-256s-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-128f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-128f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-128s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-128s-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-192f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-192f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-192s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-192s-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-256f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-256f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-256s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-256s-simple/api.h"
 }
 
 namespace crypto {
@@ -311,156 +311,156 @@ INSTANTIATE_TEST_SUITE_P(
     testing::ValuesIn<SphincsTestCase>(
         {{"SPHINCSHARAKA128FROBUST", SphincsHashType::HARAKA,
           SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSHARAKA128FROBUST_AESNI_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSHARAKA128FROBUST_AESNI_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSHARAKA128FROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA128FROBUST_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSHARAKA128SROBUST", SphincsHashType::HARAKA,
           SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSHARAKA128SROBUST_AESNI_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSHARAKA128SROBUST_AESNI_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSHARAKA128SROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA128SROBUST_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSHARAKA128FSIMPLE", SphincsHashType::HARAKA,
           SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSHARAKA128FSIMPLE_AESNI_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSHARAKA128FSIMPLE_AESNI_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSHARAKA128FSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA128FSIMPLE_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSHARAKA128SSIMPLE", SphincsHashType::HARAKA,
           SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSHARAKA128SSIMPLE_AESNI_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSHARAKA128SSIMPLE_AESNI_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSHARAKA128SSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA128SSIMPLE_CRYPTO_PUBLICKEYBYTES},
 
          {"SPHINCSHARAKA192FROBUST", SphincsHashType::HARAKA,
           SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSHARAKA192FROBUST_AESNI_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSHARAKA192FROBUST_AESNI_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSHARAKA192FROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA192FROBUST_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSHARAKA192SROBUST", SphincsHashType::HARAKA,
           SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSHARAKA192SROBUST_AESNI_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSHARAKA192SROBUST_AESNI_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSHARAKA192SROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA192SROBUST_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSHARAKA192FSIMPLE", SphincsHashType::HARAKA,
           SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSHARAKA192FSIMPLE_AESNI_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSHARAKA192FSIMPLE_AESNI_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSHARAKA192FSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA192FSIMPLE_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSHARAKA192SSIMPLE", SphincsHashType::HARAKA,
           SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSHARAKA192SSIMPLE_AESNI_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSHARAKA192SSIMPLE_AESNI_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSHARAKA192SSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA192SSIMPLE_CRYPTO_PUBLICKEYBYTES},
 
          {"SPHINCSHARAKA256FROBUST", SphincsHashType::HARAKA,
           SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSHARAKA256FROBUST_AESNI_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSHARAKA256FROBUST_AESNI_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSHARAKA256FROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA256FROBUST_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSHARAKA256SROBUST", SphincsHashType::HARAKA,
           SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSHARAKA256SROBUST_AESNI_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSHARAKA256SROBUST_AESNI_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSHARAKA256SROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA256SROBUST_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSHARAKA256FSIMPLE", SphincsHashType::HARAKA,
           SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSHARAKA256FSIMPLE_AESNI_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSHARAKA256FSIMPLE_AESNI_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSHARAKA256FSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA256FSIMPLE_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSHARAKA256SSIMPLE", SphincsHashType::HARAKA,
           SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSHARAKA256SSIMPLE_AESNI_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSHARAKA256SSIMPLE_AESNI_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSHARAKA256SSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA256SSIMPLE_CRYPTO_PUBLICKEYBYTES},
 
          {"SPHINCSSHA256128FROBUST", SphincsHashType::SHA256,
           SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHA256128FROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHA256128FROBUST_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHA256128FROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256128FROBUST_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSSHA256128SROBUST", SphincsHashType::SHA256,
           SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHA256128SROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHA256128SROBUST_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHA256128SROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256128SROBUST_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSSHA256128FSIMPLE", SphincsHashType::SHA256,
           SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHA256128FSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHA256128FSIMPLE_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHA256128FSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256128FSIMPLE_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSSHA256128SSIMPLE", SphincsHashType::SHA256,
           SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHA256128SSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHA256128SSIMPLE_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHA256128SSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256128SSIMPLE_CRYPTO_PUBLICKEYBYTES},
 
          {"SPHINCSSHA256192FROBUST", SphincsHashType::SHA256,
           SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHA256192FROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHA256192FROBUST_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHA256192FROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256192FROBUST_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSSHA256192SROBUST", SphincsHashType::SHA256,
           SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHA256192SROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHA256192SROBUST_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHA256192SROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256192SROBUST_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSSHA256192FSIMPLE", SphincsHashType::SHA256,
           SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHA256192FSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHA256192FSIMPLE_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHA256192FSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256192FSIMPLE_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSSHA256192SSIMPLE", SphincsHashType::SHA256,
           SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHA256192SSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHA256192SSIMPLE_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHA256192SSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256192SSIMPLE_CRYPTO_PUBLICKEYBYTES},
 
          {"SPHINCSSHA256256FROBUST", SphincsHashType::SHA256,
           SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHA256256FROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHA256256FROBUST_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHA256256FROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256256FROBUST_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSSHA256256SROBUST", SphincsHashType::SHA256,
           SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHA256256SROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHA256256SROBUST_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHA256256SROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256256SROBUST_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSSHA256256FSIMPLE", SphincsHashType::SHA256,
           SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHA256256FSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHA256256FSIMPLE_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHA256256FSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256256FSIMPLE_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSSHA256256SSIMPLE", SphincsHashType::SHA256,
           SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHA256256SSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHA256256SSIMPLE_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHA256256SSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256256SSIMPLE_CRYPTO_PUBLICKEYBYTES},
 
          {"SPHINCSSHAKE256128FROBUST", SphincsHashType::SHAKE256,
           SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHAKE256128FROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHAKE256128FROBUST_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHAKE256128FROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256128FROBUST_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSSHAKE256128SROBUST", SphincsHashType::SHAKE256,
           SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHAKE256128SROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHAKE256128SROBUST_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHAKE256128SROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256128SROBUST_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSSHAKE256128FSIMPLE", SphincsHashType::SHAKE256,
           SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHAKE256128FSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHAKE256128FSIMPLE_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHAKE256128FSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256128FSIMPLE_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSSHAKE256128SSIMPLE", SphincsHashType::SHAKE256,
           SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHAKE256128SSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHAKE256128SSIMPLE_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHAKE256128SSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256128SSIMPLE_CRYPTO_PUBLICKEYBYTES},
 
          {"SPHINCSSHAKE256192FROBUST", SphincsHashType::SHAKE256,
           SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHAKE256192FROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHAKE256192FROBUST_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHAKE256192FROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256192FROBUST_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSSHAKE256192SROBUST", SphincsHashType::SHAKE256,
           SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHAKE256192SROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHAKE256192SROBUST_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHAKE256192SROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256192SROBUST_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSSHAKE256192FSIMPLE", SphincsHashType::SHAKE256,
           SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHAKE256192FSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHAKE256192FSIMPLE_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHAKE256192FSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256192FSIMPLE_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSSHAKE256192SSIMPLE", SphincsHashType::SHAKE256,
           SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHAKE256192SSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHAKE256192SSIMPLE_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHAKE256192SSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256192SSIMPLE_CRYPTO_PUBLICKEYBYTES},
 
          {"SPHINCSSHAKE256256FROBUST", SphincsHashType::SHAKE256,
           SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHAKE256256FROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHAKE256256FROBUST_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHAKE256256FROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256256FROBUST_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSSHAKE256256SROBUST", SphincsHashType::SHAKE256,
           SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHAKE256256SROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHAKE256256SROBUST_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHAKE256256SROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256256SROBUST_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSSHAKE256256FSIMPLE", SphincsHashType::SHAKE256,
           SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHAKE256256FSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHAKE256256FSIMPLE_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHAKE256256FSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256256FSIMPLE_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSSHAKE256256SSIMPLE", SphincsHashType::SHAKE256,
           SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHAKE256256SSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHAKE256256SSIMPLE_AVX2_CRYPTO_PUBLICKEYBYTES}}),
+          PQCLEAN_SPHINCSSHAKE256256SSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256256SSIMPLE_CRYPTO_PUBLICKEYBYTES}}),
     [](const testing::TestParamInfo<SphincsSignKeyManagerTest::ParamType>&
            info) { return info.param.test_name; });
 
diff --git a/cc/experimental/pqcrypto/signature/sphincs_verify_key_manager_test.cc b/cc/experimental/pqcrypto/signature/sphincs_verify_key_manager_test.cc
index 2edc57cbb..29b2acafa 100644
--- a/cc/experimental/pqcrypto/signature/sphincs_verify_key_manager_test.cc
+++ b/cc/experimental/pqcrypto/signature/sphincs_verify_key_manager_test.cc
@@ -34,42 +34,42 @@
 #include "tink/util/test_matchers.h"
 
 extern "C" {
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-128f-robust/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-128f-simple/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-128s-robust/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-128s-simple/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-192f-robust/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-192f-simple/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-192s-robust/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-192s-simple/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-256f-robust/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-256f-simple/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-256s-robust/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-256s-simple/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-128f-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-128f-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-128s-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-128s-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-192f-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-192f-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-192s-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-192s-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-256f-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-256f-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-256s-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-256s-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-128f-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-128f-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-128s-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-128s-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-192f-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-192f-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-192s-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-192s-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-256f-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-256f-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-256s-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-256s-simple/avx2/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-128f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-128f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-128s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-128s-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-192f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-192f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-192s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-192s-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-256f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-256f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-256s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-256s-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-128f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-128f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-128s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-128s-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-192f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-192f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-192s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-192s-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-256f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-256f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-256s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-256s-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-128f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-128f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-128s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-128s-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-192f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-192f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-192s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-192s-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-256f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-256f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-256s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-256s-simple/api.h"
 }
 
 namespace crypto {
@@ -286,156 +286,156 @@ INSTANTIATE_TEST_SUITE_P(
     testing::ValuesIn<SphincsTestCase>(
         {{"SPHINCSHARAKA128FROBUST", SphincsHashType::HARAKA,
           SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSHARAKA128FROBUST_AESNI_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSHARAKA128FROBUST_AESNI_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSHARAKA128FROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA128FROBUST_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSHARAKA128SROBUST", SphincsHashType::HARAKA,
           SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSHARAKA128SROBUST_AESNI_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSHARAKA128SROBUST_AESNI_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSHARAKA128SROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA128SROBUST_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSHARAKA128FSIMPLE", SphincsHashType::HARAKA,
           SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSHARAKA128FSIMPLE_AESNI_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSHARAKA128FSIMPLE_AESNI_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSHARAKA128FSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA128FSIMPLE_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSHARAKA128SSIMPLE", SphincsHashType::HARAKA,
           SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSHARAKA128SSIMPLE_AESNI_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSHARAKA128SSIMPLE_AESNI_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSHARAKA128SSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA128SSIMPLE_CRYPTO_PUBLICKEYBYTES},
 
          {"SPHINCSHARAKA192FROBUST", SphincsHashType::HARAKA,
           SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSHARAKA192FROBUST_AESNI_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSHARAKA192FROBUST_AESNI_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSHARAKA192FROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA192FROBUST_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSHARAKA192SROBUST", SphincsHashType::HARAKA,
           SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSHARAKA192SROBUST_AESNI_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSHARAKA192SROBUST_AESNI_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSHARAKA192SROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA192SROBUST_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSHARAKA192FSIMPLE", SphincsHashType::HARAKA,
           SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSHARAKA192FSIMPLE_AESNI_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSHARAKA192FSIMPLE_AESNI_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSHARAKA192FSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA192FSIMPLE_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSHARAKA192SSIMPLE", SphincsHashType::HARAKA,
           SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSHARAKA192SSIMPLE_AESNI_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSHARAKA192SSIMPLE_AESNI_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSHARAKA192SSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA192SSIMPLE_CRYPTO_PUBLICKEYBYTES},
 
          {"SPHINCSHARAKA256FROBUST", SphincsHashType::HARAKA,
           SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSHARAKA256FROBUST_AESNI_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSHARAKA256FROBUST_AESNI_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSHARAKA256FROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA256FROBUST_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSHARAKA256SROBUST", SphincsHashType::HARAKA,
           SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSHARAKA256SROBUST_AESNI_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSHARAKA256SROBUST_AESNI_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSHARAKA256SROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA256SROBUST_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSHARAKA256FSIMPLE", SphincsHashType::HARAKA,
           SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSHARAKA256FSIMPLE_AESNI_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSHARAKA256FSIMPLE_AESNI_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSHARAKA256FSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA256FSIMPLE_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSHARAKA256SSIMPLE", SphincsHashType::HARAKA,
           SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSHARAKA256SSIMPLE_AESNI_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSHARAKA256SSIMPLE_AESNI_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSHARAKA256SSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA256SSIMPLE_CRYPTO_PUBLICKEYBYTES},
 
          {"SPHINCSSHA256128FROBUST", SphincsHashType::SHA256,
           SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHA256128FROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHA256128FROBUST_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHA256128FROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256128FROBUST_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSSHA256128SROBUST", SphincsHashType::SHA256,
           SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHA256128SROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHA256128SROBUST_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHA256128SROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256128SROBUST_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSSHA256128FSIMPLE", SphincsHashType::SHA256,
           SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHA256128FSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHA256128FSIMPLE_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHA256128FSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256128FSIMPLE_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSSHA256128SSIMPLE", SphincsHashType::SHA256,
           SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHA256128SSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHA256128SSIMPLE_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHA256128SSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256128SSIMPLE_CRYPTO_PUBLICKEYBYTES},
 
          {"SPHINCSSHA256192FROBUST", SphincsHashType::SHA256,
           SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHA256192FROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHA256192FROBUST_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHA256192FROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256192FROBUST_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSSHA256192SROBUST", SphincsHashType::SHA256,
           SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHA256192SROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHA256192SROBUST_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHA256192SROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256192SROBUST_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSSHA256192FSIMPLE", SphincsHashType::SHA256,
           SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHA256192FSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHA256192FSIMPLE_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHA256192FSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256192FSIMPLE_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSSHA256192SSIMPLE", SphincsHashType::SHA256,
           SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHA256192SSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHA256192SSIMPLE_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHA256192SSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256192SSIMPLE_CRYPTO_PUBLICKEYBYTES},
 
          {"SPHINCSSHA256256FROBUST", SphincsHashType::SHA256,
           SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHA256256FROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHA256256FROBUST_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHA256256FROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256256FROBUST_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSSHA256256SROBUST", SphincsHashType::SHA256,
           SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHA256256SROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHA256256SROBUST_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHA256256SROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256256SROBUST_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSSHA256256FSIMPLE", SphincsHashType::SHA256,
           SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHA256256FSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHA256256FSIMPLE_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHA256256FSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256256FSIMPLE_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSSHA256256SSIMPLE", SphincsHashType::SHA256,
           SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHA256256SSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHA256256SSIMPLE_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHA256256SSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256256SSIMPLE_CRYPTO_PUBLICKEYBYTES},
 
          {"SPHINCSSHAKE256128FROBUST", SphincsHashType::SHAKE256,
           SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHAKE256128FROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHAKE256128FROBUST_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHAKE256128FROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256128FROBUST_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSSHAKE256128SROBUST", SphincsHashType::SHAKE256,
           SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHAKE256128SROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHAKE256128SROBUST_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHAKE256128SROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256128SROBUST_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSSHAKE256128FSIMPLE", SphincsHashType::SHAKE256,
           SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHAKE256128FSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHAKE256128FSIMPLE_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHAKE256128FSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256128FSIMPLE_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSSHAKE256128SSIMPLE", SphincsHashType::SHAKE256,
           SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHAKE256128SSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHAKE256128SSIMPLE_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHAKE256128SSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256128SSIMPLE_CRYPTO_PUBLICKEYBYTES},
 
          {"SPHINCSSHAKE256192FROBUST", SphincsHashType::SHAKE256,
           SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHAKE256192FROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHAKE256192FROBUST_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHAKE256192FROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256192FROBUST_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSSHAKE256192SROBUST", SphincsHashType::SHAKE256,
           SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHAKE256192SROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHAKE256192SROBUST_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHAKE256192SROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256192SROBUST_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSSHAKE256192FSIMPLE", SphincsHashType::SHAKE256,
           SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHAKE256192FSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHAKE256192FSIMPLE_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHAKE256192FSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256192FSIMPLE_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSSHAKE256192SSIMPLE", SphincsHashType::SHAKE256,
           SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHAKE256192SSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHAKE256192SSIMPLE_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHAKE256192SSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256192SSIMPLE_CRYPTO_PUBLICKEYBYTES},
 
          {"SPHINCSSHAKE256256FROBUST", SphincsHashType::SHAKE256,
           SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHAKE256256FROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHAKE256256FROBUST_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHAKE256256FROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256256FROBUST_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSSHAKE256256SROBUST", SphincsHashType::SHAKE256,
           SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHAKE256256SROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHAKE256256SROBUST_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHAKE256256SROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256256SROBUST_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSSHAKE256256FSIMPLE", SphincsHashType::SHAKE256,
           SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHAKE256256FSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHAKE256256FSIMPLE_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHAKE256256FSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256256FSIMPLE_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSSHAKE256256SSIMPLE", SphincsHashType::SHAKE256,
           SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHAKE256256SSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHAKE256256SSIMPLE_AVX2_CRYPTO_PUBLICKEYBYTES}}),
+          PQCLEAN_SPHINCSSHAKE256256SSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256256SSIMPLE_CRYPTO_PUBLICKEYBYTES}}),
     [](const testing::TestParamInfo<SphincsVerifyKeyManagerTest::ParamType>&
            info) { return info.param.test_name; });
 
diff --git a/cc/experimental/pqcrypto/signature/subtle/dilithium_avx2_sign.cc b/cc/experimental/pqcrypto/signature/subtle/dilithium_avx2_sign.cc
index ff0fca680..6fd6d82e0 100644
--- a/cc/experimental/pqcrypto/signature/subtle/dilithium_avx2_sign.cc
+++ b/cc/experimental/pqcrypto/signature/subtle/dilithium_avx2_sign.cc
@@ -32,12 +32,12 @@
 #include "tink/util/statusor.h"
 
 extern "C" {
-#include "third_party/pqclean/crypto_sign/dilithium2/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/dilithium2aes/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/dilithium3/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/dilithium3aes/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/dilithium5/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/dilithium5aes/avx2/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium2/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium2aes/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium3/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium3aes/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium5/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium5aes/api.h"
 }
 
 namespace crypto {
@@ -52,17 +52,17 @@ util::StatusOr<std::unique_ptr<PublicKeySign>> DilithiumAvx2Sign::New(
 
   int32_t key_size = private_key.GetKeyData().size();
 
-  if (key_size != PQCLEAN_DILITHIUM2_AVX2_CRYPTO_SECRETKEYBYTES &&
-      key_size != PQCLEAN_DILITHIUM3_AVX2_CRYPTO_SECRETKEYBYTES &&
-      key_size != PQCLEAN_DILITHIUM5_AVX2_CRYPTO_SECRETKEYBYTES) {
+  if (key_size != PQCLEAN_DILITHIUM2_CRYPTO_SECRETKEYBYTES &&
+      key_size != PQCLEAN_DILITHIUM3_CRYPTO_SECRETKEYBYTES &&
+      key_size != PQCLEAN_DILITHIUM5_CRYPTO_SECRETKEYBYTES) {
     return util::Status(
         absl::StatusCode::kInvalidArgument,
         absl::StrFormat("Invalid private key size (%d). "
                         "The only valid sizes are %d, %d, %d.",
                         private_key.GetKeyData().size(),
-                        PQCLEAN_DILITHIUM2_AVX2_CRYPTO_SECRETKEYBYTES,
-                        PQCLEAN_DILITHIUM3_AVX2_CRYPTO_SECRETKEYBYTES,
-                        PQCLEAN_DILITHIUM5_AVX2_CRYPTO_SECRETKEYBYTES));
+                        PQCLEAN_DILITHIUM2_CRYPTO_SECRETKEYBYTES,
+                        PQCLEAN_DILITHIUM3_CRYPTO_SECRETKEYBYTES,
+                        PQCLEAN_DILITHIUM5_CRYPTO_SECRETKEYBYTES));
   }
 
   return {absl::WrapUnique(new DilithiumAvx2Sign(std::move(private_key)))};
@@ -76,11 +76,11 @@ util::StatusOr<std::string> DilithiumAvx2Sign::Sign(
   int result = 1;
 
   switch (key_size) {
-    case PQCLEAN_DILITHIUM2_AVX2_CRYPTO_SECRETKEYBYTES: {
+    case PQCLEAN_DILITHIUM2_CRYPTO_SECRETKEYBYTES: {
       switch (private_key_.GetSeedExpansion()) {
         case DilithiumSeedExpansion::SEED_EXPANSION_AES: {
-          signature.resize(PQCLEAN_DILITHIUM2AES_AVX2_CRYPTO_BYTES, '0');
-          result = PQCLEAN_DILITHIUM2AES_AVX2_crypto_sign_signature(
+          signature.resize(PQCLEAN_DILITHIUM2AES_CRYPTO_BYTES, '0');
+          result = PQCLEAN_DILITHIUM2AES_crypto_sign_signature(
               reinterpret_cast<uint8_t *>(signature.data()), &sig_length,
               reinterpret_cast<const uint8_t *>(data.data()), data.size(),
               reinterpret_cast<const uint8_t *>(
@@ -88,8 +88,8 @@ util::StatusOr<std::string> DilithiumAvx2Sign::Sign(
           break;
         }
         case DilithiumSeedExpansion::SEED_EXPANSION_SHAKE: {
-          signature.resize(PQCLEAN_DILITHIUM2_AVX2_CRYPTO_BYTES, '0');
-          result = PQCLEAN_DILITHIUM2_AVX2_crypto_sign_signature(
+          signature.resize(PQCLEAN_DILITHIUM2_CRYPTO_BYTES, '0');
+          result = PQCLEAN_DILITHIUM2_crypto_sign_signature(
               reinterpret_cast<uint8_t *>(signature.data()), &sig_length,
               reinterpret_cast<const uint8_t *>(data.data()), data.size(),
               reinterpret_cast<const uint8_t *>(
@@ -104,11 +104,11 @@ util::StatusOr<std::string> DilithiumAvx2Sign::Sign(
       }
       break;
     }
-    case PQCLEAN_DILITHIUM3_AVX2_CRYPTO_SECRETKEYBYTES: {
+    case PQCLEAN_DILITHIUM3_CRYPTO_SECRETKEYBYTES: {
       switch (private_key_.GetSeedExpansion()) {
         case DilithiumSeedExpansion::SEED_EXPANSION_AES: {
-          signature.resize(PQCLEAN_DILITHIUM3AES_AVX2_CRYPTO_BYTES, '0');
-          result = PQCLEAN_DILITHIUM3AES_AVX2_crypto_sign_signature(
+          signature.resize(PQCLEAN_DILITHIUM3AES_CRYPTO_BYTES, '0');
+          result = PQCLEAN_DILITHIUM3AES_crypto_sign_signature(
               reinterpret_cast<uint8_t *>(signature.data()), &sig_length,
               reinterpret_cast<const uint8_t *>(data.data()), data.size(),
               reinterpret_cast<const uint8_t *>(
@@ -116,8 +116,8 @@ util::StatusOr<std::string> DilithiumAvx2Sign::Sign(
           break;
         }
         case DilithiumSeedExpansion::SEED_EXPANSION_SHAKE: {
-          signature.resize(PQCLEAN_DILITHIUM3_AVX2_CRYPTO_BYTES, '0');
-          result = PQCLEAN_DILITHIUM3_AVX2_crypto_sign_signature(
+          signature.resize(PQCLEAN_DILITHIUM3_CRYPTO_BYTES, '0');
+          result = PQCLEAN_DILITHIUM3_crypto_sign_signature(
               reinterpret_cast<uint8_t *>(signature.data()), &sig_length,
               reinterpret_cast<const uint8_t *>(data.data()), data.size(),
               reinterpret_cast<const uint8_t *>(
@@ -131,11 +131,11 @@ util::StatusOr<std::string> DilithiumAvx2Sign::Sign(
       }
       break;
     }
-    case PQCLEAN_DILITHIUM5_AVX2_CRYPTO_SECRETKEYBYTES: {
+    case PQCLEAN_DILITHIUM5_CRYPTO_SECRETKEYBYTES: {
       switch (private_key_.GetSeedExpansion()) {
         case DilithiumSeedExpansion::SEED_EXPANSION_AES: {
-          signature.resize(PQCLEAN_DILITHIUM5AES_AVX2_CRYPTO_BYTES, '0');
-          result = PQCLEAN_DILITHIUM5AES_AVX2_crypto_sign_signature(
+          signature.resize(PQCLEAN_DILITHIUM5AES_CRYPTO_BYTES, '0');
+          result = PQCLEAN_DILITHIUM5AES_crypto_sign_signature(
               reinterpret_cast<uint8_t *>(signature.data()), &sig_length,
               reinterpret_cast<const uint8_t *>(data.data()), data.size(),
               reinterpret_cast<const uint8_t *>(
@@ -143,8 +143,8 @@ util::StatusOr<std::string> DilithiumAvx2Sign::Sign(
           break;
         }
         case DilithiumSeedExpansion::SEED_EXPANSION_SHAKE: {
-          signature.resize(PQCLEAN_DILITHIUM5_AVX2_CRYPTO_BYTES, '0');
-          result = PQCLEAN_DILITHIUM5_AVX2_crypto_sign_signature(
+          signature.resize(PQCLEAN_DILITHIUM5_CRYPTO_BYTES, '0');
+          result = PQCLEAN_DILITHIUM5_crypto_sign_signature(
               reinterpret_cast<uint8_t *>(signature.data()), &sig_length,
               reinterpret_cast<const uint8_t *>(data.data()), data.size(),
               reinterpret_cast<const uint8_t *>(
diff --git a/cc/experimental/pqcrypto/signature/subtle/dilithium_avx2_sign_test.cc b/cc/experimental/pqcrypto/signature/subtle/dilithium_avx2_sign_test.cc
index 42f2b4d44..3f7030f8c 100644
--- a/cc/experimental/pqcrypto/signature/subtle/dilithium_avx2_sign_test.cc
+++ b/cc/experimental/pqcrypto/signature/subtle/dilithium_avx2_sign_test.cc
@@ -34,12 +34,12 @@
 #include "tink/util/test_matchers.h"
 
 extern "C" {
-#include "third_party/pqclean/crypto_sign/dilithium2/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/dilithium2aes/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/dilithium3/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/dilithium3aes/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/dilithium5/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/dilithium5aes/avx2/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium2/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium2aes/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium3/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium3aes/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium5/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium5aes/api.h"
 }
 
 namespace crypto {
@@ -66,10 +66,10 @@ TEST(DilithiumAvx2SignTest, InvalidPrivateKeys) {
   }
 
   for (int keysize = 0;
-       keysize <= PQCLEAN_DILITHIUM5_AVX2_CRYPTO_SECRETKEYBYTES; keysize++) {
-    if (keysize == PQCLEAN_DILITHIUM2_AVX2_CRYPTO_SECRETKEYBYTES ||
-        keysize == PQCLEAN_DILITHIUM3_AVX2_CRYPTO_SECRETKEYBYTES ||
-        keysize == PQCLEAN_DILITHIUM5_AVX2_CRYPTO_SECRETKEYBYTES) {
+       keysize <= PQCLEAN_DILITHIUM5_CRYPTO_SECRETKEYBYTES; keysize++) {
+    if (keysize == PQCLEAN_DILITHIUM2_CRYPTO_SECRETKEYBYTES ||
+        keysize == PQCLEAN_DILITHIUM3_CRYPTO_SECRETKEYBYTES ||
+        keysize == PQCLEAN_DILITHIUM5_CRYPTO_SECRETKEYBYTES) {
       // Valid key size.
       continue;
     }
@@ -181,23 +181,23 @@ TEST_P(DilithiumAvx2SignTest, FipsMode) {
 INSTANTIATE_TEST_SUITE_P(
     DilithiumAvx2SignTests, DilithiumAvx2SignTest,
     testing::ValuesIn<DilithiumTestCase>({
-        {"Dilithium2", PQCLEAN_DILITHIUM2_AVX2_CRYPTO_SECRETKEYBYTES,
-         PQCLEAN_DILITHIUM2_AVX2_CRYPTO_BYTES,
+        {"Dilithium2", PQCLEAN_DILITHIUM2_CRYPTO_SECRETKEYBYTES,
+         PQCLEAN_DILITHIUM2_CRYPTO_BYTES,
          DilithiumSeedExpansion::SEED_EXPANSION_SHAKE},
-        {"Dilithium3", PQCLEAN_DILITHIUM3_AVX2_CRYPTO_SECRETKEYBYTES,
-         PQCLEAN_DILITHIUM3_AVX2_CRYPTO_BYTES,
+        {"Dilithium3", PQCLEAN_DILITHIUM3_CRYPTO_SECRETKEYBYTES,
+         PQCLEAN_DILITHIUM3_CRYPTO_BYTES,
          DilithiumSeedExpansion::SEED_EXPANSION_SHAKE},
-        {"Dilithium5", PQCLEAN_DILITHIUM5_AVX2_CRYPTO_SECRETKEYBYTES,
-         PQCLEAN_DILITHIUM5_AVX2_CRYPTO_BYTES,
+        {"Dilithium5", PQCLEAN_DILITHIUM5_CRYPTO_SECRETKEYBYTES,
+         PQCLEAN_DILITHIUM5_CRYPTO_BYTES,
          DilithiumSeedExpansion::SEED_EXPANSION_SHAKE},
-        {"Dilithium2Aes", PQCLEAN_DILITHIUM2AES_AVX2_CRYPTO_SECRETKEYBYTES,
-         PQCLEAN_DILITHIUM2AES_AVX2_CRYPTO_BYTES,
+        {"Dilithium2Aes", PQCLEAN_DILITHIUM2AES_CRYPTO_SECRETKEYBYTES,
+         PQCLEAN_DILITHIUM2AES_CRYPTO_BYTES,
          DilithiumSeedExpansion::SEED_EXPANSION_AES},
-        {"Dilithium3Aes", PQCLEAN_DILITHIUM3AES_AVX2_CRYPTO_SECRETKEYBYTES,
-         PQCLEAN_DILITHIUM3_AVX2_CRYPTO_BYTES,
+        {"Dilithium3Aes", PQCLEAN_DILITHIUM3AES_CRYPTO_SECRETKEYBYTES,
+         PQCLEAN_DILITHIUM3_CRYPTO_BYTES,
          DilithiumSeedExpansion::SEED_EXPANSION_AES},
-        {"Dilithium5Aes", PQCLEAN_DILITHIUM5AES_AVX2_CRYPTO_SECRETKEYBYTES,
-         PQCLEAN_DILITHIUM5AES_AVX2_CRYPTO_BYTES,
+        {"Dilithium5Aes", PQCLEAN_DILITHIUM5AES_CRYPTO_SECRETKEYBYTES,
+         PQCLEAN_DILITHIUM5AES_CRYPTO_BYTES,
          DilithiumSeedExpansion::SEED_EXPANSION_AES},
     }),
     [](const testing::TestParamInfo<DilithiumAvx2SignTest::ParamType>& info) {
diff --git a/cc/experimental/pqcrypto/signature/subtle/dilithium_avx2_verify.cc b/cc/experimental/pqcrypto/signature/subtle/dilithium_avx2_verify.cc
index a427d45d0..b12c44f51 100644
--- a/cc/experimental/pqcrypto/signature/subtle/dilithium_avx2_verify.cc
+++ b/cc/experimental/pqcrypto/signature/subtle/dilithium_avx2_verify.cc
@@ -31,12 +31,12 @@
 #include "tink/util/statusor.h"
 
 extern "C" {
-#include "third_party/pqclean/crypto_sign/dilithium2/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/dilithium2aes/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/dilithium3/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/dilithium3aes/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/dilithium5/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/dilithium5aes/avx2/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium2/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium2aes/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium3/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium3aes/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium5/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium5aes/api.h"
 }
 
 namespace crypto {
@@ -51,16 +51,16 @@ util::StatusOr<std::unique_ptr<PublicKeyVerify>> DilithiumAvx2Verify::New(
 
   int32_t key_size = public_key.GetKeyData().size();
 
-  if (key_size != PQCLEAN_DILITHIUM2_AVX2_CRYPTO_PUBLICKEYBYTES &&
-      key_size != PQCLEAN_DILITHIUM3_AVX2_CRYPTO_PUBLICKEYBYTES &&
-      key_size != PQCLEAN_DILITHIUM5_AVX2_CRYPTO_PUBLICKEYBYTES) {
+  if (key_size != PQCLEAN_DILITHIUM2_CRYPTO_PUBLICKEYBYTES &&
+      key_size != PQCLEAN_DILITHIUM3_CRYPTO_PUBLICKEYBYTES &&
+      key_size != PQCLEAN_DILITHIUM5_CRYPTO_PUBLICKEYBYTES) {
     return util::Status(
         absl::StatusCode::kInvalidArgument,
         absl::StrFormat("Invalid public key size (%d). "
                         "The only valid sizes are %d, %d, %d.",
-                        key_size, PQCLEAN_DILITHIUM2_AVX2_CRYPTO_PUBLICKEYBYTES,
-                        PQCLEAN_DILITHIUM3_AVX2_CRYPTO_PUBLICKEYBYTES,
-                        PQCLEAN_DILITHIUM5_AVX2_CRYPTO_PUBLICKEYBYTES));
+                        key_size, PQCLEAN_DILITHIUM2_CRYPTO_PUBLICKEYBYTES,
+                        PQCLEAN_DILITHIUM3_CRYPTO_PUBLICKEYBYTES,
+                        PQCLEAN_DILITHIUM5_CRYPTO_PUBLICKEYBYTES));
   }
 
   return {absl::WrapUnique(new DilithiumAvx2Verify(std::move(public_key)))};
@@ -72,10 +72,10 @@ util::Status DilithiumAvx2Verify::Verify(absl::string_view signature,
   int result = 1;
 
   switch (key_size) {
-    case PQCLEAN_DILITHIUM2_AVX2_CRYPTO_PUBLICKEYBYTES: {
+    case PQCLEAN_DILITHIUM2_CRYPTO_PUBLICKEYBYTES: {
       switch (public_key_.GetSeedExpansion()) {
         case DilithiumSeedExpansion::SEED_EXPANSION_AES: {
-          result = PQCLEAN_DILITHIUM2AES_AVX2_crypto_sign_verify(
+          result = PQCLEAN_DILITHIUM2AES_crypto_sign_verify(
               reinterpret_cast<const uint8_t *>(signature.data()),
               signature.size(), reinterpret_cast<const uint8_t *>(data.data()),
               data.size(),
@@ -85,7 +85,7 @@ util::Status DilithiumAvx2Verify::Verify(absl::string_view signature,
           break;
         }
         case DilithiumSeedExpansion::SEED_EXPANSION_SHAKE: {
-          result = PQCLEAN_DILITHIUM2_AVX2_crypto_sign_verify(
+          result = PQCLEAN_DILITHIUM2_crypto_sign_verify(
               reinterpret_cast<const uint8_t *>(signature.data()),
               signature.size(), reinterpret_cast<const uint8_t *>(data.data()),
               data.size(),
@@ -100,10 +100,10 @@ util::Status DilithiumAvx2Verify::Verify(absl::string_view signature,
       }
       break;
     }
-    case PQCLEAN_DILITHIUM3_AVX2_CRYPTO_PUBLICKEYBYTES: {
+    case PQCLEAN_DILITHIUM3_CRYPTO_PUBLICKEYBYTES: {
       switch (public_key_.GetSeedExpansion()) {
         case DilithiumSeedExpansion::SEED_EXPANSION_AES: {
-          result = PQCLEAN_DILITHIUM3AES_AVX2_crypto_sign_verify(
+          result = PQCLEAN_DILITHIUM3AES_crypto_sign_verify(
               reinterpret_cast<const uint8_t *>(signature.data()),
               signature.size(), reinterpret_cast<const uint8_t *>(data.data()),
               data.size(),
@@ -112,7 +112,7 @@ util::Status DilithiumAvx2Verify::Verify(absl::string_view signature,
           break;
         }
         case DilithiumSeedExpansion::SEED_EXPANSION_SHAKE: {
-          result = PQCLEAN_DILITHIUM3_AVX2_crypto_sign_verify(
+          result = PQCLEAN_DILITHIUM3_crypto_sign_verify(
               reinterpret_cast<const uint8_t *>(signature.data()),
               signature.size(), reinterpret_cast<const uint8_t *>(data.data()),
               data.size(),
@@ -127,10 +127,10 @@ util::Status DilithiumAvx2Verify::Verify(absl::string_view signature,
       }
       break;
     }
-    case PQCLEAN_DILITHIUM5_AVX2_CRYPTO_PUBLICKEYBYTES: {
+    case PQCLEAN_DILITHIUM5_CRYPTO_PUBLICKEYBYTES: {
       switch (public_key_.GetSeedExpansion()) {
         case DilithiumSeedExpansion::SEED_EXPANSION_AES: {
-          result = PQCLEAN_DILITHIUM5AES_AVX2_crypto_sign_verify(
+          result = PQCLEAN_DILITHIUM5AES_crypto_sign_verify(
               reinterpret_cast<const uint8_t *>(signature.data()),
               signature.size(), reinterpret_cast<const uint8_t *>(data.data()),
               data.size(),
@@ -139,7 +139,7 @@ util::Status DilithiumAvx2Verify::Verify(absl::string_view signature,
           break;
         }
         case DilithiumSeedExpansion::SEED_EXPANSION_SHAKE: {
-          result = PQCLEAN_DILITHIUM5_AVX2_crypto_sign_verify(
+          result = PQCLEAN_DILITHIUM5_crypto_sign_verify(
               reinterpret_cast<const uint8_t *>(signature.data()),
               signature.size(), reinterpret_cast<const uint8_t *>(data.data()),
               data.size(),
diff --git a/cc/experimental/pqcrypto/signature/subtle/dilithium_avx2_verify_test.cc b/cc/experimental/pqcrypto/signature/subtle/dilithium_avx2_verify_test.cc
index 978355a51..ef37f5a63 100644
--- a/cc/experimental/pqcrypto/signature/subtle/dilithium_avx2_verify_test.cc
+++ b/cc/experimental/pqcrypto/signature/subtle/dilithium_avx2_verify_test.cc
@@ -36,12 +36,12 @@
 #include "tink/util/test_matchers.h"
 
 extern "C" {
-#include "third_party/pqclean/crypto_sign/dilithium2/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/dilithium2aes/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/dilithium3/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/dilithium3aes/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/dilithium5/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/dilithium5aes/avx2/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium2/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium2aes/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium3/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium3aes/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium5/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium5aes/api.h"
 }
 
 namespace crypto {
@@ -74,11 +74,11 @@ TEST(DilithiumAvx2VerifyTest, InvalidPublicKeys) {
               null_public_key, DilithiumSeedExpansion::SEED_EXPANSION_SHAKE))
           .ok());
 
-  for (int keysize = 0; keysize < PQCLEAN_DILITHIUM2_AVX2_CRYPTO_PUBLICKEYBYTES;
+  for (int keysize = 0; keysize < PQCLEAN_DILITHIUM2_CRYPTO_PUBLICKEYBYTES;
        keysize++) {
-    if (keysize == PQCLEAN_DILITHIUM2_AVX2_CRYPTO_PUBLICKEYBYTES ||
-        keysize == PQCLEAN_DILITHIUM3_AVX2_CRYPTO_PUBLICKEYBYTES ||
-        keysize == PQCLEAN_DILITHIUM5_AVX2_CRYPTO_PUBLICKEYBYTES) {
+    if (keysize == PQCLEAN_DILITHIUM2_CRYPTO_PUBLICKEYBYTES ||
+        keysize == PQCLEAN_DILITHIUM3_CRYPTO_PUBLICKEYBYTES ||
+        keysize == PQCLEAN_DILITHIUM5_CRYPTO_PUBLICKEYBYTES) {
       // Valid key size.
       continue;
     }
@@ -1431,17 +1431,17 @@ TEST(DilithiumAvx2VerifyTest, AesVectors) {
 INSTANTIATE_TEST_SUITE_P(
     DilithiumAvx2VerifyTests, DilithiumAvx2VerifyTest,
     testing::ValuesIn<DilithiumTestCase>({
-        {"Dilithium2", PQCLEAN_DILITHIUM2_AVX2_CRYPTO_SECRETKEYBYTES,
+        {"Dilithium2", PQCLEAN_DILITHIUM2_CRYPTO_SECRETKEYBYTES,
          DilithiumSeedExpansion::SEED_EXPANSION_SHAKE},
-        {"Dilithium3", PQCLEAN_DILITHIUM3_AVX2_CRYPTO_SECRETKEYBYTES,
+        {"Dilithium3", PQCLEAN_DILITHIUM3_CRYPTO_SECRETKEYBYTES,
          DilithiumSeedExpansion::SEED_EXPANSION_SHAKE},
-        {"Dilithium5", PQCLEAN_DILITHIUM5_AVX2_CRYPTO_SECRETKEYBYTES,
+        {"Dilithium5", PQCLEAN_DILITHIUM5_CRYPTO_SECRETKEYBYTES,
          DilithiumSeedExpansion::SEED_EXPANSION_SHAKE},
-        {"Dilithium2Aes", PQCLEAN_DILITHIUM2AES_AVX2_CRYPTO_SECRETKEYBYTES,
+        {"Dilithium2Aes", PQCLEAN_DILITHIUM2AES_CRYPTO_SECRETKEYBYTES,
          DilithiumSeedExpansion::SEED_EXPANSION_AES},
-        {"Dilithium3Aes", PQCLEAN_DILITHIUM3AES_AVX2_CRYPTO_SECRETKEYBYTES,
+        {"Dilithium3Aes", PQCLEAN_DILITHIUM3AES_CRYPTO_SECRETKEYBYTES,
          DilithiumSeedExpansion::SEED_EXPANSION_AES},
-        {"Dilithium5Aes", PQCLEAN_DILITHIUM5AES_AVX2_CRYPTO_SECRETKEYBYTES,
+        {"Dilithium5Aes", PQCLEAN_DILITHIUM5AES_CRYPTO_SECRETKEYBYTES,
          DilithiumSeedExpansion::SEED_EXPANSION_AES},
     }),
     [](const testing::TestParamInfo<DilithiumAvx2VerifyTest::ParamType>& info) {
diff --git a/cc/experimental/pqcrypto/signature/subtle/dilithium_key.cc b/cc/experimental/pqcrypto/signature/subtle/dilithium_key.cc
index 12f940ec7..a51142244 100644
--- a/cc/experimental/pqcrypto/signature/subtle/dilithium_key.cc
+++ b/cc/experimental/pqcrypto/signature/subtle/dilithium_key.cc
@@ -26,12 +26,12 @@
 #include "tink/util/statusor.h"
 
 extern "C" {
-#include "third_party/pqclean/crypto_sign/dilithium2/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/dilithium2aes/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/dilithium3/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/dilithium3aes/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/dilithium5/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/dilithium5aes/avx2/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium2/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium2aes/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium3/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium3aes/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium5/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium5aes/api.h"
 }
 
 namespace crypto {
@@ -56,18 +56,18 @@ DilithiumPrivateKeyPqclean::GenerateKeyPair(
   // Check if the key_size parameter is correct.
   switch (private_key_size) {
     // Dilithium2.
-    case PQCLEAN_DILITHIUM2_AVX2_CRYPTO_SECRETKEYBYTES: {
+    case PQCLEAN_DILITHIUM2_CRYPTO_SECRETKEYBYTES: {
       switch (seed_expansion) {
         case DilithiumSeedExpansion::SEED_EXPANSION_AES: {
-          public_key.resize(PQCLEAN_DILITHIUM2AES_AVX2_CRYPTO_PUBLICKEYBYTES);
-          PQCLEAN_DILITHIUM2AES_AVX2_crypto_sign_keypair(
+          public_key.resize(PQCLEAN_DILITHIUM2AES_CRYPTO_PUBLICKEYBYTES);
+          PQCLEAN_DILITHIUM2AES_crypto_sign_keypair(
               reinterpret_cast<uint8_t*>(public_key.data()),
               reinterpret_cast<uint8_t*>(private_key.data()));
           break;
         }
         case DilithiumSeedExpansion::SEED_EXPANSION_SHAKE: {
-          public_key.resize(PQCLEAN_DILITHIUM2_AVX2_CRYPTO_PUBLICKEYBYTES);
-          PQCLEAN_DILITHIUM2_AVX2_crypto_sign_keypair(
+          public_key.resize(PQCLEAN_DILITHIUM2_CRYPTO_PUBLICKEYBYTES);
+          PQCLEAN_DILITHIUM2_crypto_sign_keypair(
               reinterpret_cast<uint8_t*>(public_key.data()),
               reinterpret_cast<uint8_t*>(private_key.data()));
           break;
@@ -80,18 +80,18 @@ DilithiumPrivateKeyPqclean::GenerateKeyPair(
       break;
     }
     // Dilithium3.
-    case PQCLEAN_DILITHIUM3_AVX2_CRYPTO_SECRETKEYBYTES: {
+    case PQCLEAN_DILITHIUM3_CRYPTO_SECRETKEYBYTES: {
       switch (seed_expansion) {
         case DilithiumSeedExpansion::SEED_EXPANSION_AES: {
-          public_key.resize(PQCLEAN_DILITHIUM3AES_AVX2_CRYPTO_PUBLICKEYBYTES);
-          PQCLEAN_DILITHIUM3AES_AVX2_crypto_sign_keypair(
+          public_key.resize(PQCLEAN_DILITHIUM3AES_CRYPTO_PUBLICKEYBYTES);
+          PQCLEAN_DILITHIUM3AES_crypto_sign_keypair(
               reinterpret_cast<uint8_t*>(public_key.data()),
               reinterpret_cast<uint8_t*>(private_key.data()));
           break;
         }
         case DilithiumSeedExpansion::SEED_EXPANSION_SHAKE: {
-          public_key.resize(PQCLEAN_DILITHIUM3_AVX2_CRYPTO_PUBLICKEYBYTES);
-          PQCLEAN_DILITHIUM3_AVX2_crypto_sign_keypair(
+          public_key.resize(PQCLEAN_DILITHIUM3_CRYPTO_PUBLICKEYBYTES);
+          PQCLEAN_DILITHIUM3_crypto_sign_keypair(
               reinterpret_cast<uint8_t*>(public_key.data()),
               reinterpret_cast<uint8_t*>(private_key.data()));
           break;
@@ -104,18 +104,18 @@ DilithiumPrivateKeyPqclean::GenerateKeyPair(
       break;
     }
     // Dilithium5.
-    case PQCLEAN_DILITHIUM5_AVX2_CRYPTO_SECRETKEYBYTES: {
+    case PQCLEAN_DILITHIUM5_CRYPTO_SECRETKEYBYTES: {
       switch (seed_expansion) {
         case DilithiumSeedExpansion::SEED_EXPANSION_AES: {
-          public_key.resize(PQCLEAN_DILITHIUM5AES_AVX2_CRYPTO_PUBLICKEYBYTES);
-          PQCLEAN_DILITHIUM5AES_AVX2_crypto_sign_keypair(
+          public_key.resize(PQCLEAN_DILITHIUM5AES_CRYPTO_PUBLICKEYBYTES);
+          PQCLEAN_DILITHIUM5AES_crypto_sign_keypair(
               reinterpret_cast<uint8_t*>(public_key.data()),
               reinterpret_cast<uint8_t*>(private_key.data()));
           break;
         }
         case DilithiumSeedExpansion::SEED_EXPANSION_SHAKE: {
-          public_key.resize(PQCLEAN_DILITHIUM5_AVX2_CRYPTO_PUBLICKEYBYTES);
-          PQCLEAN_DILITHIUM5_AVX2_crypto_sign_keypair(
+          public_key.resize(PQCLEAN_DILITHIUM5_CRYPTO_PUBLICKEYBYTES);
+          PQCLEAN_DILITHIUM5_crypto_sign_keypair(
               reinterpret_cast<uint8_t*>(public_key.data()),
               reinterpret_cast<uint8_t*>(private_key.data()));
           break;
@@ -134,9 +134,9 @@ DilithiumPrivateKeyPqclean::GenerateKeyPair(
           absl::StrFormat("Invalid private key size (%d). "
                           "The only valid sizes are %d, %d, %d.",
                           private_key_size,
-                          PQCLEAN_DILITHIUM2_AVX2_CRYPTO_SECRETKEYBYTES,
-                          PQCLEAN_DILITHIUM3_AVX2_CRYPTO_SECRETKEYBYTES,
-                          PQCLEAN_DILITHIUM5_AVX2_CRYPTO_SECRETKEYBYTES));
+                          PQCLEAN_DILITHIUM2_CRYPTO_SECRETKEYBYTES,
+                          PQCLEAN_DILITHIUM3_CRYPTO_SECRETKEYBYTES,
+                          PQCLEAN_DILITHIUM5_CRYPTO_SECRETKEYBYTES));
     }
   }
 
diff --git a/cc/experimental/pqcrypto/signature/subtle/dilithium_key_test.cc b/cc/experimental/pqcrypto/signature/subtle/dilithium_key_test.cc
index 3bd78ea55..dd71572db 100644
--- a/cc/experimental/pqcrypto/signature/subtle/dilithium_key_test.cc
+++ b/cc/experimental/pqcrypto/signature/subtle/dilithium_key_test.cc
@@ -27,12 +27,12 @@
 #include "tink/util/test_matchers.h"
 
 extern "C" {
-#include "third_party/pqclean/crypto_sign/dilithium2/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/dilithium2aes/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/dilithium3/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/dilithium3aes/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/dilithium5/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/dilithium5aes/avx2/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium2/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium2aes/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium3/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium3aes/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium5/api.h"
+#include "third_party/pqclean/crypto_sign/dilithium5aes/api.h"
 }
 
 namespace crypto {
@@ -86,23 +86,23 @@ TEST_P(DilithiumKeyTest, DifferentContent) {
 INSTANTIATE_TEST_SUITE_P(
     DilithiumKeyTesta, DilithiumKeyTest,
     testing::ValuesIn<DilithiumTestCase>({
-        {"Dilithium2", PQCLEAN_DILITHIUM2_AVX2_CRYPTO_SECRETKEYBYTES,
-         PQCLEAN_DILITHIUM2_AVX2_CRYPTO_PUBLICKEYBYTES,
+        {"Dilithium2", PQCLEAN_DILITHIUM2_CRYPTO_SECRETKEYBYTES,
+         PQCLEAN_DILITHIUM2_CRYPTO_PUBLICKEYBYTES,
          DilithiumSeedExpansion::SEED_EXPANSION_SHAKE},
-        {"Dilithium3", PQCLEAN_DILITHIUM3_AVX2_CRYPTO_SECRETKEYBYTES,
-         PQCLEAN_DILITHIUM3_AVX2_CRYPTO_PUBLICKEYBYTES,
+        {"Dilithium3", PQCLEAN_DILITHIUM3_CRYPTO_SECRETKEYBYTES,
+         PQCLEAN_DILITHIUM3_CRYPTO_PUBLICKEYBYTES,
          DilithiumSeedExpansion::SEED_EXPANSION_SHAKE},
-        {"Dilithium5", PQCLEAN_DILITHIUM5_AVX2_CRYPTO_SECRETKEYBYTES,
-         PQCLEAN_DILITHIUM5_AVX2_CRYPTO_PUBLICKEYBYTES,
+        {"Dilithium5", PQCLEAN_DILITHIUM5_CRYPTO_SECRETKEYBYTES,
+         PQCLEAN_DILITHIUM5_CRYPTO_PUBLICKEYBYTES,
          DilithiumSeedExpansion::SEED_EXPANSION_SHAKE},
-        {"Dilithium2Aes", PQCLEAN_DILITHIUM2AES_AVX2_CRYPTO_SECRETKEYBYTES,
-         PQCLEAN_DILITHIUM2AES_AVX2_CRYPTO_PUBLICKEYBYTES,
+        {"Dilithium2Aes", PQCLEAN_DILITHIUM2AES_CRYPTO_SECRETKEYBYTES,
+         PQCLEAN_DILITHIUM2AES_CRYPTO_PUBLICKEYBYTES,
          DilithiumSeedExpansion::SEED_EXPANSION_AES},
-        {"Dilithium3Aes", PQCLEAN_DILITHIUM3AES_AVX2_CRYPTO_SECRETKEYBYTES,
-         PQCLEAN_DILITHIUM3AES_AVX2_CRYPTO_PUBLICKEYBYTES,
+        {"Dilithium3Aes", PQCLEAN_DILITHIUM3AES_CRYPTO_SECRETKEYBYTES,
+         PQCLEAN_DILITHIUM3AES_CRYPTO_PUBLICKEYBYTES,
          DilithiumSeedExpansion::SEED_EXPANSION_AES},
-        {"Dilithium5Aes", PQCLEAN_DILITHIUM5AES_AVX2_CRYPTO_SECRETKEYBYTES,
-         PQCLEAN_DILITHIUM5AES_AVX2_CRYPTO_PUBLICKEYBYTES,
+        {"Dilithium5Aes", PQCLEAN_DILITHIUM5AES_CRYPTO_SECRETKEYBYTES,
+         PQCLEAN_DILITHIUM5AES_CRYPTO_PUBLICKEYBYTES,
          DilithiumSeedExpansion::SEED_EXPANSION_AES},
     }),
     [](const testing::TestParamInfo<DilithiumKeyTest::ParamType>& info) {
diff --git a/cc/experimental/pqcrypto/signature/subtle/falcon_sign.cc b/cc/experimental/pqcrypto/signature/subtle/falcon_sign.cc
index ed0e8ce78..63196a21f 100644
--- a/cc/experimental/pqcrypto/signature/subtle/falcon_sign.cc
+++ b/cc/experimental/pqcrypto/signature/subtle/falcon_sign.cc
@@ -27,8 +27,8 @@
 #include "tink/util/statusor.h"
 
 extern "C" {
-#include "third_party/pqclean/crypto_sign/falcon-1024/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/falcon-512/avx2/api.h"
+#include "third_party/pqclean/crypto_sign/falcon-1024/api.h"
+#include "third_party/pqclean/crypto_sign/falcon-512/api.h"
 }
 
 namespace crypto {
@@ -52,23 +52,23 @@ util::StatusOr<std::string> FalconSign::Sign(absl::string_view data) const {
 
   switch (key_size) {
     case kFalcon512PrivateKeySize: {
-      signature.resize(PQCLEAN_FALCON512_AVX2_CRYPTO_BYTES, '0');
-      result = PQCLEAN_FALCON512_AVX2_crypto_sign_signature(
+      signature.resize(PQCLEAN_FALCON512_CRYPTO_BYTES, '0');
+      result = PQCLEAN_FALCON512_crypto_sign_signature(
           reinterpret_cast<uint8_t *>(signature.data()), &sig_length,
           reinterpret_cast<const uint8_t *>(data.data()), data.size(),
           reinterpret_cast<const uint8_t *>(private_key_.GetKey().data()));
-      if (sig_length > PQCLEAN_FALCON512_AVX2_CRYPTO_BYTES) {
+      if (sig_length > PQCLEAN_FALCON512_CRYPTO_BYTES) {
         result = -1;
       }
       break;
     }
     case kFalcon1024PrivateKeySize: {
-      signature.resize(PQCLEAN_FALCON1024_AVX2_CRYPTO_BYTES, '0');
-      result = PQCLEAN_FALCON1024_AVX2_crypto_sign_signature(
+      signature.resize(PQCLEAN_FALCON1024_CRYPTO_BYTES, '0');
+      result = PQCLEAN_FALCON1024_crypto_sign_signature(
           reinterpret_cast<uint8_t *>(signature.data()), &sig_length,
           reinterpret_cast<const uint8_t *>(data.data()), data.size(),
           reinterpret_cast<const uint8_t *>(private_key_.GetKey().data()));
-      if (sig_length > PQCLEAN_FALCON1024_AVX2_CRYPTO_BYTES) {
+      if (sig_length > PQCLEAN_FALCON1024_CRYPTO_BYTES) {
         result = -1;
       }
       break;
diff --git a/cc/experimental/pqcrypto/signature/subtle/falcon_sign_test.cc b/cc/experimental/pqcrypto/signature/subtle/falcon_sign_test.cc
index 61094a38f..bca1e3648 100644
--- a/cc/experimental/pqcrypto/signature/subtle/falcon_sign_test.cc
+++ b/cc/experimental/pqcrypto/signature/subtle/falcon_sign_test.cc
@@ -29,8 +29,8 @@
 #include "tink/util/test_matchers.h"
 
 extern "C" {
-#include "third_party/pqclean/crypto_sign/falcon-1024/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/falcon-512/avx2/api.h"
+#include "third_party/pqclean/crypto_sign/falcon-1024/api.h"
+#include "third_party/pqclean/crypto_sign/falcon-512/api.h"
 }
 
 namespace crypto {
@@ -131,9 +131,9 @@ TEST_P(FalconSignTest, FipsMode) {
 INSTANTIATE_TEST_SUITE_P(
     FalconSignTests, FalconSignTest,
     testing::ValuesIn<FalconTestCase>({{"Falcon512", kFalcon512PrivateKeySize,
-                                        PQCLEAN_FALCON512_AVX2_CRYPTO_BYTES},
+                                        PQCLEAN_FALCON512_CRYPTO_BYTES},
                                        {"Falcon1024", kFalcon1024PrivateKeySize,
-                                        PQCLEAN_FALCON1024_AVX2_CRYPTO_BYTES}}),
+                                        PQCLEAN_FALCON1024_CRYPTO_BYTES}}),
     [](const testing::TestParamInfo<FalconSignTest::ParamType>& info) {
       return info.param.test_name;
     });
diff --git a/cc/experimental/pqcrypto/signature/subtle/falcon_subtle_utils.cc b/cc/experimental/pqcrypto/signature/subtle/falcon_subtle_utils.cc
index b05d061c2..b0b664b5c 100644
--- a/cc/experimental/pqcrypto/signature/subtle/falcon_subtle_utils.cc
+++ b/cc/experimental/pqcrypto/signature/subtle/falcon_subtle_utils.cc
@@ -28,8 +28,8 @@
 #include "tink/util/statusor.h"
 
 extern "C" {
-#include "third_party/pqclean/crypto_sign/falcon-1024/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/falcon-512/avx2/api.h"
+#include "third_party/pqclean/crypto_sign/falcon-1024/api.h"
+#include "third_party/pqclean/crypto_sign/falcon-512/api.h"
 }
 
 namespace crypto {
@@ -68,7 +68,7 @@ crypto::tink::util::StatusOr<FalconKeyPair> GenerateFalconKeyPair(
     case kFalcon512PrivateKeySize: {
       private_key.resize(private_key_size);
       public_key.resize(kFalcon512PublicKeySize);
-      PQCLEAN_FALCON512_AVX2_crypto_sign_keypair(
+      PQCLEAN_FALCON512_crypto_sign_keypair(
           reinterpret_cast<uint8_t*>(public_key.data()),
           reinterpret_cast<uint8_t*>(private_key.data()));
       break;
@@ -77,7 +77,7 @@ crypto::tink::util::StatusOr<FalconKeyPair> GenerateFalconKeyPair(
     case kFalcon1024PrivateKeySize: {
       private_key.resize(private_key_size);
       public_key.resize(kFalcon1024PublicKeySize);
-      PQCLEAN_FALCON1024_AVX2_crypto_sign_keypair(
+      PQCLEAN_FALCON1024_crypto_sign_keypair(
           reinterpret_cast<uint8_t*>(public_key.data()),
           reinterpret_cast<uint8_t*>(private_key.data()));
       break;
diff --git a/cc/experimental/pqcrypto/signature/subtle/falcon_verify.cc b/cc/experimental/pqcrypto/signature/subtle/falcon_verify.cc
index 4aefd41df..1284c30da 100644
--- a/cc/experimental/pqcrypto/signature/subtle/falcon_verify.cc
+++ b/cc/experimental/pqcrypto/signature/subtle/falcon_verify.cc
@@ -27,8 +27,8 @@
 #include "tink/util/statusor.h"
 
 extern "C" {
-#include "third_party/pqclean/crypto_sign/falcon-1024/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/falcon-512/avx2/api.h"
+#include "third_party/pqclean/crypto_sign/falcon-1024/api.h"
+#include "third_party/pqclean/crypto_sign/falcon-512/api.h"
 }
 
 namespace crypto {
@@ -52,14 +52,14 @@ util::Status FalconVerify::Verify(absl::string_view signature,
 
   switch (key_size) {
     case kFalcon512PublicKeySize: {
-      result = PQCLEAN_FALCON512_AVX2_crypto_sign_verify(
+      result = PQCLEAN_FALCON512_crypto_sign_verify(
           reinterpret_cast<const uint8_t *>(signature.data()), signature.size(),
           reinterpret_cast<const uint8_t *>(data.data()), data.size(),
           reinterpret_cast<const uint8_t *>(public_key_.GetKey().data()));
       break;
     }
     case kFalcon1024PublicKeySize: {
-      result = PQCLEAN_FALCON1024_AVX2_crypto_sign_verify(
+      result = PQCLEAN_FALCON1024_crypto_sign_verify(
           reinterpret_cast<const uint8_t *>(signature.data()), signature.size(),
           reinterpret_cast<const uint8_t *>(data.data()), data.size(),
           reinterpret_cast<const uint8_t *>(public_key_.GetKey().data()));
diff --git a/cc/experimental/pqcrypto/signature/subtle/falcon_verify_test.cc b/cc/experimental/pqcrypto/signature/subtle/falcon_verify_test.cc
index 361100eaa..8db691ed2 100644
--- a/cc/experimental/pqcrypto/signature/subtle/falcon_verify_test.cc
+++ b/cc/experimental/pqcrypto/signature/subtle/falcon_verify_test.cc
@@ -34,8 +34,8 @@
 #include "tink/util/test_matchers.h"
 
 extern "C" {
-#include "third_party/pqclean/crypto_sign/falcon-1024/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/falcon-512/avx2/api.h"
+#include "third_party/pqclean/crypto_sign/falcon-1024/api.h"
+#include "third_party/pqclean/crypto_sign/falcon-512/api.h"
 }
 
 namespace crypto {
@@ -207,9 +207,9 @@ TEST_P(FalconVerifyTest, FipsMode) {
 INSTANTIATE_TEST_SUITE_P(
     FalconVerifyTests, FalconVerifyTest,
     testing::ValuesIn<FalconTestCase>({{"Falcon512", kFalcon512PrivateKeySize,
-                                        PQCLEAN_FALCON512_AVX2_CRYPTO_BYTES},
+                                        PQCLEAN_FALCON512_CRYPTO_BYTES},
                                        {"Falcon1024", kFalcon1024PrivateKeySize,
-                                        PQCLEAN_FALCON1024_AVX2_CRYPTO_BYTES}}),
+                                        PQCLEAN_FALCON1024_CRYPTO_BYTES}}),
     [](const testing::TestParamInfo<FalconVerifyTest::ParamType>& info) {
       return info.param.test_name;
     });
diff --git a/cc/experimental/pqcrypto/signature/subtle/sphincs_helper_pqclean.cc b/cc/experimental/pqcrypto/signature/subtle/sphincs_helper_pqclean.cc
index 52b20e5c4..3809f2f5f 100644
--- a/cc/experimental/pqcrypto/signature/subtle/sphincs_helper_pqclean.cc
+++ b/cc/experimental/pqcrypto/signature/subtle/sphincs_helper_pqclean.cc
@@ -23,42 +23,42 @@
 #include "absl/memory/memory.h"
 
 extern "C" {
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-128f-robust/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-128f-simple/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-128s-robust/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-128s-simple/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-192f-robust/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-192f-simple/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-192s-robust/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-192s-simple/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-256f-robust/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-256f-simple/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-256s-robust/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-256s-simple/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-128f-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-128f-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-128s-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-128s-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-192f-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-192f-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-192s-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-192s-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-256f-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-256f-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-256s-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-256s-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-128f-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-128f-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-128s-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-128s-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-192f-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-192f-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-192s-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-192s-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-256f-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-256f-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-256s-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-256s-simple/avx2/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-128f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-128f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-128s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-128s-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-192f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-192f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-192s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-192s-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-256f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-256f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-256s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-256s-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-128f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-128f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-128s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-128s-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-192f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-192f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-192s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-192s-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-256f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-256f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-256s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-256s-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-128f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-128f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-128s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-128s-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-192f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-192f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-192s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-192s-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-256f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-256f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-256s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-256s-simple/api.h"
 }
 
 #define NUM_VARIANTS 2
@@ -73,25 +73,25 @@ class SphincsHaraka128FRobustPqclean : public SphincsHelperPqclean {
  public:
   SphincsHaraka128FRobustPqclean()
       : SphincsHelperPqclean(
-            PQCLEAN_SPHINCSHARAKA128FROBUST_AESNI_CRYPTO_PUBLICKEYBYTES,
-            PQCLEAN_SPHINCSHARAKA128FROBUST_AESNI_CRYPTO_BYTES) {}
+            PQCLEAN_SPHINCSHARAKA128FROBUST_CRYPTO_PUBLICKEYBYTES,
+            PQCLEAN_SPHINCSHARAKA128FROBUST_CRYPTO_BYTES) {}
 
   ~SphincsHaraka128FRobustPqclean() override = default;
 
   int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
            const uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSHARAKA128FROBUST_AESNI_crypto_sign_signature(
+    return PQCLEAN_SPHINCSHARAKA128FROBUST_crypto_sign_signature(
         sig, siglen, m, mlen, sk);
   }
 
   int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
              const uint8_t *pk) const override {
-    return PQCLEAN_SPHINCSHARAKA128FROBUST_AESNI_crypto_sign_verify(
+    return PQCLEAN_SPHINCSHARAKA128FROBUST_crypto_sign_verify(
         sig, siglen, m, mlen, pk);
   }
 
   int Keygen(uint8_t *pk, uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSHARAKA128FROBUST_AESNI_crypto_sign_keypair(pk, sk);
+    return PQCLEAN_SPHINCSHARAKA128FROBUST_crypto_sign_keypair(pk, sk);
   }
 };
 
@@ -99,25 +99,25 @@ class SphincsHaraka128SRobustPqclean : public SphincsHelperPqclean {
  public:
   SphincsHaraka128SRobustPqclean()
       : SphincsHelperPqclean(
-            PQCLEAN_SPHINCSHARAKA128SROBUST_AESNI_CRYPTO_PUBLICKEYBYTES,
-            PQCLEAN_SPHINCSHARAKA128SROBUST_AESNI_CRYPTO_BYTES) {}
+            PQCLEAN_SPHINCSHARAKA128SROBUST_CRYPTO_PUBLICKEYBYTES,
+            PQCLEAN_SPHINCSHARAKA128SROBUST_CRYPTO_BYTES) {}
 
   ~SphincsHaraka128SRobustPqclean() override = default;
 
   int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
            const uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSHARAKA128SROBUST_AESNI_crypto_sign_signature(
+    return PQCLEAN_SPHINCSHARAKA128SROBUST_crypto_sign_signature(
         sig, siglen, m, mlen, sk);
   }
 
   int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
              const uint8_t *pk) const override {
-    return PQCLEAN_SPHINCSHARAKA128SROBUST_AESNI_crypto_sign_verify(
+    return PQCLEAN_SPHINCSHARAKA128SROBUST_crypto_sign_verify(
         sig, siglen, m, mlen, pk);
   }
 
   int Keygen(uint8_t *pk, uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSHARAKA128SROBUST_AESNI_crypto_sign_keypair(pk, sk);
+    return PQCLEAN_SPHINCSHARAKA128SROBUST_crypto_sign_keypair(pk, sk);
   }
 };
 
@@ -125,25 +125,25 @@ class SphincsHaraka128FSimplePqclean : public SphincsHelperPqclean {
  public:
   SphincsHaraka128FSimplePqclean()
       : SphincsHelperPqclean(
-            PQCLEAN_SPHINCSHARAKA128FSIMPLE_AESNI_CRYPTO_PUBLICKEYBYTES,
-            PQCLEAN_SPHINCSHARAKA128FSIMPLE_AESNI_CRYPTO_BYTES) {}
+            PQCLEAN_SPHINCSHARAKA128FSIMPLE_CRYPTO_PUBLICKEYBYTES,
+            PQCLEAN_SPHINCSHARAKA128FSIMPLE_CRYPTO_BYTES) {}
 
   ~SphincsHaraka128FSimplePqclean() override = default;
 
   int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
            const uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSHARAKA128FSIMPLE_AESNI_crypto_sign_signature(
+    return PQCLEAN_SPHINCSHARAKA128FSIMPLE_crypto_sign_signature(
         sig, siglen, m, mlen, sk);
   }
 
   int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
              const uint8_t *pk) const override {
-    return PQCLEAN_SPHINCSHARAKA128FSIMPLE_AESNI_crypto_sign_verify(
+    return PQCLEAN_SPHINCSHARAKA128FSIMPLE_crypto_sign_verify(
         sig, siglen, m, mlen, pk);
   }
 
   int Keygen(uint8_t *pk, uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSHARAKA128FSIMPLE_AESNI_crypto_sign_keypair(pk, sk);
+    return PQCLEAN_SPHINCSHARAKA128FSIMPLE_crypto_sign_keypair(pk, sk);
   }
 };
 
@@ -151,25 +151,25 @@ class SphincsHaraka128SSimplePqclean : public SphincsHelperPqclean {
  public:
   SphincsHaraka128SSimplePqclean()
       : SphincsHelperPqclean(
-            PQCLEAN_SPHINCSHARAKA128SSIMPLE_AESNI_CRYPTO_PUBLICKEYBYTES,
-            PQCLEAN_SPHINCSHARAKA128SSIMPLE_AESNI_CRYPTO_BYTES) {}
+            PQCLEAN_SPHINCSHARAKA128SSIMPLE_CRYPTO_PUBLICKEYBYTES,
+            PQCLEAN_SPHINCSHARAKA128SSIMPLE_CRYPTO_BYTES) {}
 
   ~SphincsHaraka128SSimplePqclean() override = default;
 
   int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
            const uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSHARAKA128SSIMPLE_AESNI_crypto_sign_signature(
+    return PQCLEAN_SPHINCSHARAKA128SSIMPLE_crypto_sign_signature(
         sig, siglen, m, mlen, sk);
   }
 
   int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
              const uint8_t *pk) const override {
-    return PQCLEAN_SPHINCSHARAKA128SSIMPLE_AESNI_crypto_sign_verify(
+    return PQCLEAN_SPHINCSHARAKA128SSIMPLE_crypto_sign_verify(
         sig, siglen, m, mlen, pk);
   }
 
   int Keygen(uint8_t *pk, uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSHARAKA128SSIMPLE_AESNI_crypto_sign_keypair(pk, sk);
+    return PQCLEAN_SPHINCSHARAKA128SSIMPLE_crypto_sign_keypair(pk, sk);
   }
 };
 
@@ -177,25 +177,25 @@ class SphincsHaraka192FRobustPqclean : public SphincsHelperPqclean {
  public:
   SphincsHaraka192FRobustPqclean()
       : SphincsHelperPqclean(
-            PQCLEAN_SPHINCSHARAKA192FROBUST_AESNI_CRYPTO_PUBLICKEYBYTES,
-            PQCLEAN_SPHINCSHARAKA192FROBUST_AESNI_CRYPTO_BYTES) {}
+            PQCLEAN_SPHINCSHARAKA192FROBUST_CRYPTO_PUBLICKEYBYTES,
+            PQCLEAN_SPHINCSHARAKA192FROBUST_CRYPTO_BYTES) {}
 
   ~SphincsHaraka192FRobustPqclean() override = default;
 
   int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
            const uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSHARAKA192FROBUST_AESNI_crypto_sign_signature(
+    return PQCLEAN_SPHINCSHARAKA192FROBUST_crypto_sign_signature(
         sig, siglen, m, mlen, sk);
   }
 
   int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
              const uint8_t *pk) const override {
-    return PQCLEAN_SPHINCSHARAKA192FROBUST_AESNI_crypto_sign_verify(
+    return PQCLEAN_SPHINCSHARAKA192FROBUST_crypto_sign_verify(
         sig, siglen, m, mlen, pk);
   }
 
   int Keygen(uint8_t *pk, uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSHARAKA192FROBUST_AESNI_crypto_sign_keypair(pk, sk);
+    return PQCLEAN_SPHINCSHARAKA192FROBUST_crypto_sign_keypair(pk, sk);
   }
 };
 
@@ -203,25 +203,25 @@ class SphincsHaraka192SRobustPqclean : public SphincsHelperPqclean {
  public:
   SphincsHaraka192SRobustPqclean()
       : SphincsHelperPqclean(
-            PQCLEAN_SPHINCSHARAKA192SROBUST_AESNI_CRYPTO_PUBLICKEYBYTES,
-            PQCLEAN_SPHINCSHARAKA192SROBUST_AESNI_CRYPTO_BYTES) {}
+            PQCLEAN_SPHINCSHARAKA192SROBUST_CRYPTO_PUBLICKEYBYTES,
+            PQCLEAN_SPHINCSHARAKA192SROBUST_CRYPTO_BYTES) {}
 
   ~SphincsHaraka192SRobustPqclean() override = default;
 
   int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
            const uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSHARAKA192SROBUST_AESNI_crypto_sign_signature(
+    return PQCLEAN_SPHINCSHARAKA192SROBUST_crypto_sign_signature(
         sig, siglen, m, mlen, sk);
   }
 
   int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
              const uint8_t *pk) const override {
-    return PQCLEAN_SPHINCSHARAKA192SROBUST_AESNI_crypto_sign_verify(
+    return PQCLEAN_SPHINCSHARAKA192SROBUST_crypto_sign_verify(
         sig, siglen, m, mlen, pk);
   }
 
   int Keygen(uint8_t *pk, uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSHARAKA192SROBUST_AESNI_crypto_sign_keypair(pk, sk);
+    return PQCLEAN_SPHINCSHARAKA192SROBUST_crypto_sign_keypair(pk, sk);
   }
 };
 
@@ -229,25 +229,25 @@ class SphincsHaraka192FSimplePqclean : public SphincsHelperPqclean {
  public:
   SphincsHaraka192FSimplePqclean()
       : SphincsHelperPqclean(
-            PQCLEAN_SPHINCSHARAKA192FSIMPLE_AESNI_CRYPTO_PUBLICKEYBYTES,
-            PQCLEAN_SPHINCSHARAKA192FSIMPLE_AESNI_CRYPTO_BYTES) {}
+            PQCLEAN_SPHINCSHARAKA192FSIMPLE_CRYPTO_PUBLICKEYBYTES,
+            PQCLEAN_SPHINCSHARAKA192FSIMPLE_CRYPTO_BYTES) {}
 
   ~SphincsHaraka192FSimplePqclean() override = default;
 
   int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
            const uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSHARAKA192FSIMPLE_AESNI_crypto_sign_signature(
+    return PQCLEAN_SPHINCSHARAKA192FSIMPLE_crypto_sign_signature(
         sig, siglen, m, mlen, sk);
   }
 
   int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
              const uint8_t *pk) const override {
-    return PQCLEAN_SPHINCSHARAKA192FSIMPLE_AESNI_crypto_sign_verify(
+    return PQCLEAN_SPHINCSHARAKA192FSIMPLE_crypto_sign_verify(
         sig, siglen, m, mlen, pk);
   }
 
   int Keygen(uint8_t *pk, uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSHARAKA192FSIMPLE_AESNI_crypto_sign_keypair(pk, sk);
+    return PQCLEAN_SPHINCSHARAKA192FSIMPLE_crypto_sign_keypair(pk, sk);
   }
 };
 
@@ -255,25 +255,25 @@ class SphincsHaraka192SSimplePqclean : public SphincsHelperPqclean {
  public:
   SphincsHaraka192SSimplePqclean()
       : SphincsHelperPqclean(
-            PQCLEAN_SPHINCSHARAKA192SSIMPLE_AESNI_CRYPTO_PUBLICKEYBYTES,
-            PQCLEAN_SPHINCSHARAKA192SSIMPLE_AESNI_CRYPTO_BYTES) {}
+            PQCLEAN_SPHINCSHARAKA192SSIMPLE_CRYPTO_PUBLICKEYBYTES,
+            PQCLEAN_SPHINCSHARAKA192SSIMPLE_CRYPTO_BYTES) {}
 
   ~SphincsHaraka192SSimplePqclean() override = default;
 
   int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
            const uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSHARAKA192SSIMPLE_AESNI_crypto_sign_signature(
+    return PQCLEAN_SPHINCSHARAKA192SSIMPLE_crypto_sign_signature(
         sig, siglen, m, mlen, sk);
   }
 
   int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
              const uint8_t *pk) const override {
-    return PQCLEAN_SPHINCSHARAKA192SSIMPLE_AESNI_crypto_sign_verify(
+    return PQCLEAN_SPHINCSHARAKA192SSIMPLE_crypto_sign_verify(
         sig, siglen, m, mlen, pk);
   }
 
   int Keygen(uint8_t *pk, uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSHARAKA192SSIMPLE_AESNI_crypto_sign_keypair(pk, sk);
+    return PQCLEAN_SPHINCSHARAKA192SSIMPLE_crypto_sign_keypair(pk, sk);
   }
 };
 
@@ -281,25 +281,25 @@ class SphincsHaraka256FRobustPqclean : public SphincsHelperPqclean {
  public:
   SphincsHaraka256FRobustPqclean()
       : SphincsHelperPqclean(
-            PQCLEAN_SPHINCSHARAKA256FROBUST_AESNI_CRYPTO_PUBLICKEYBYTES,
-            PQCLEAN_SPHINCSHARAKA256FROBUST_AESNI_CRYPTO_BYTES) {}
+            PQCLEAN_SPHINCSHARAKA256FROBUST_CRYPTO_PUBLICKEYBYTES,
+            PQCLEAN_SPHINCSHARAKA256FROBUST_CRYPTO_BYTES) {}
 
   ~SphincsHaraka256FRobustPqclean() override = default;
 
   int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
            const uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSHARAKA256FROBUST_AESNI_crypto_sign_signature(
+    return PQCLEAN_SPHINCSHARAKA256FROBUST_crypto_sign_signature(
         sig, siglen, m, mlen, sk);
   }
 
   int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
              const uint8_t *pk) const override {
-    return PQCLEAN_SPHINCSHARAKA256FROBUST_AESNI_crypto_sign_verify(
+    return PQCLEAN_SPHINCSHARAKA256FROBUST_crypto_sign_verify(
         sig, siglen, m, mlen, pk);
   }
 
   int Keygen(uint8_t *pk, uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSHARAKA256FROBUST_AESNI_crypto_sign_keypair(pk, sk);
+    return PQCLEAN_SPHINCSHARAKA256FROBUST_crypto_sign_keypair(pk, sk);
   }
 };
 
@@ -307,25 +307,25 @@ class SphincsHaraka256SRobustPqclean : public SphincsHelperPqclean {
  public:
   SphincsHaraka256SRobustPqclean()
       : SphincsHelperPqclean(
-            PQCLEAN_SPHINCSHARAKA256SROBUST_AESNI_CRYPTO_PUBLICKEYBYTES,
-            PQCLEAN_SPHINCSHARAKA256SROBUST_AESNI_CRYPTO_BYTES) {}
+            PQCLEAN_SPHINCSHARAKA256SROBUST_CRYPTO_PUBLICKEYBYTES,
+            PQCLEAN_SPHINCSHARAKA256SROBUST_CRYPTO_BYTES) {}
 
   ~SphincsHaraka256SRobustPqclean() override = default;
 
   int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
            const uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSHARAKA256SROBUST_AESNI_crypto_sign_signature(
+    return PQCLEAN_SPHINCSHARAKA256SROBUST_crypto_sign_signature(
         sig, siglen, m, mlen, sk);
   }
 
   int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
              const uint8_t *pk) const override {
-    return PQCLEAN_SPHINCSHARAKA256SROBUST_AESNI_crypto_sign_verify(
+    return PQCLEAN_SPHINCSHARAKA256SROBUST_crypto_sign_verify(
         sig, siglen, m, mlen, pk);
   }
 
   int Keygen(uint8_t *pk, uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSHARAKA256SROBUST_AESNI_crypto_sign_keypair(pk, sk);
+    return PQCLEAN_SPHINCSHARAKA256SROBUST_crypto_sign_keypair(pk, sk);
   }
 };
 
@@ -333,25 +333,25 @@ class SphincsHaraka256FSimplePqclean : public SphincsHelperPqclean {
  public:
   SphincsHaraka256FSimplePqclean()
       : SphincsHelperPqclean(
-            PQCLEAN_SPHINCSHARAKA256FSIMPLE_AESNI_CRYPTO_PUBLICKEYBYTES,
-            PQCLEAN_SPHINCSHARAKA256FSIMPLE_AESNI_CRYPTO_BYTES) {}
+            PQCLEAN_SPHINCSHARAKA256FSIMPLE_CRYPTO_PUBLICKEYBYTES,
+            PQCLEAN_SPHINCSHARAKA256FSIMPLE_CRYPTO_BYTES) {}
 
   ~SphincsHaraka256FSimplePqclean() override = default;
 
   int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
            const uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSHARAKA256FSIMPLE_AESNI_crypto_sign_signature(
+    return PQCLEAN_SPHINCSHARAKA256FSIMPLE_crypto_sign_signature(
         sig, siglen, m, mlen, sk);
   }
 
   int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
              const uint8_t *pk) const override {
-    return PQCLEAN_SPHINCSHARAKA256FSIMPLE_AESNI_crypto_sign_verify(
+    return PQCLEAN_SPHINCSHARAKA256FSIMPLE_crypto_sign_verify(
         sig, siglen, m, mlen, pk);
   }
 
   int Keygen(uint8_t *pk, uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSHARAKA256FSIMPLE_AESNI_crypto_sign_keypair(pk, sk);
+    return PQCLEAN_SPHINCSHARAKA256FSIMPLE_crypto_sign_keypair(pk, sk);
   }
 };
 
@@ -359,25 +359,25 @@ class SphincsHaraka256SSimplePqclean : public SphincsHelperPqclean {
  public:
   SphincsHaraka256SSimplePqclean()
       : SphincsHelperPqclean(
-            PQCLEAN_SPHINCSHARAKA256SSIMPLE_AESNI_CRYPTO_PUBLICKEYBYTES,
-            PQCLEAN_SPHINCSHARAKA256SSIMPLE_AESNI_CRYPTO_BYTES) {}
+            PQCLEAN_SPHINCSHARAKA256SSIMPLE_CRYPTO_PUBLICKEYBYTES,
+            PQCLEAN_SPHINCSHARAKA256SSIMPLE_CRYPTO_BYTES) {}
 
   ~SphincsHaraka256SSimplePqclean() override = default;
 
   int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
            const uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSHARAKA256SSIMPLE_AESNI_crypto_sign_signature(
+    return PQCLEAN_SPHINCSHARAKA256SSIMPLE_crypto_sign_signature(
         sig, siglen, m, mlen, sk);
   }
 
   int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
              const uint8_t *pk) const override {
-    return PQCLEAN_SPHINCSHARAKA256SSIMPLE_AESNI_crypto_sign_verify(
+    return PQCLEAN_SPHINCSHARAKA256SSIMPLE_crypto_sign_verify(
         sig, siglen, m, mlen, pk);
   }
 
   int Keygen(uint8_t *pk, uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSHARAKA256SSIMPLE_AESNI_crypto_sign_keypair(pk, sk);
+    return PQCLEAN_SPHINCSHARAKA256SSIMPLE_crypto_sign_keypair(pk, sk);
   }
 };
 
@@ -385,25 +385,25 @@ class SphincsSHA256128FRobustPqclean : public SphincsHelperPqclean {
  public:
   SphincsSHA256128FRobustPqclean()
       : SphincsHelperPqclean(
-            PQCLEAN_SPHINCSSHA256128FROBUST_AVX2_CRYPTO_PUBLICKEYBYTES,
-            PQCLEAN_SPHINCSSHA256128FROBUST_AVX2_CRYPTO_BYTES) {}
+            PQCLEAN_SPHINCSSHA256128FROBUST_CRYPTO_PUBLICKEYBYTES,
+            PQCLEAN_SPHINCSSHA256128FROBUST_CRYPTO_BYTES) {}
 
   ~SphincsSHA256128FRobustPqclean() override = default;
 
   int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
            const uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSSHA256128FROBUST_AVX2_crypto_sign_signature(
+    return PQCLEAN_SPHINCSSHA256128FROBUST_crypto_sign_signature(
         sig, siglen, m, mlen, sk);
   }
 
   int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
              const uint8_t *pk) const override {
-    return PQCLEAN_SPHINCSSHA256128FROBUST_AVX2_crypto_sign_verify(sig, siglen,
+    return PQCLEAN_SPHINCSSHA256128FROBUST_crypto_sign_verify(sig, siglen,
                                                                    m, mlen, pk);
   }
 
   int Keygen(uint8_t *pk, uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSSHA256128FROBUST_AVX2_crypto_sign_keypair(pk, sk);
+    return PQCLEAN_SPHINCSSHA256128FROBUST_crypto_sign_keypair(pk, sk);
   }
 };
 
@@ -411,25 +411,25 @@ class SphincsSHA256128SRobustPqclean : public SphincsHelperPqclean {
  public:
   SphincsSHA256128SRobustPqclean()
       : SphincsHelperPqclean(
-            PQCLEAN_SPHINCSSHA256128SROBUST_AVX2_CRYPTO_PUBLICKEYBYTES,
-            PQCLEAN_SPHINCSSHA256128SROBUST_AVX2_CRYPTO_BYTES) {}
+            PQCLEAN_SPHINCSSHA256128SROBUST_CRYPTO_PUBLICKEYBYTES,
+            PQCLEAN_SPHINCSSHA256128SROBUST_CRYPTO_BYTES) {}
 
   ~SphincsSHA256128SRobustPqclean() override = default;
 
   int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
            const uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSSHA256128SROBUST_AVX2_crypto_sign_signature(
+    return PQCLEAN_SPHINCSSHA256128SROBUST_crypto_sign_signature(
         sig, siglen, m, mlen, sk);
   }
 
   int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
              const uint8_t *pk) const override {
-    return PQCLEAN_SPHINCSSHA256128SROBUST_AVX2_crypto_sign_verify(sig, siglen,
+    return PQCLEAN_SPHINCSSHA256128SROBUST_crypto_sign_verify(sig, siglen,
                                                                    m, mlen, pk);
   }
 
   int Keygen(uint8_t *pk, uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSSHA256128SROBUST_AVX2_crypto_sign_keypair(pk, sk);
+    return PQCLEAN_SPHINCSSHA256128SROBUST_crypto_sign_keypair(pk, sk);
   }
 };
 
@@ -437,25 +437,25 @@ class SphincsSHA256128FSimplePqclean : public SphincsHelperPqclean {
  public:
   SphincsSHA256128FSimplePqclean()
       : SphincsHelperPqclean(
-            PQCLEAN_SPHINCSSHA256128FSIMPLE_AVX2_CRYPTO_PUBLICKEYBYTES,
-            PQCLEAN_SPHINCSSHA256128FSIMPLE_AVX2_CRYPTO_BYTES) {}
+            PQCLEAN_SPHINCSSHA256128FSIMPLE_CRYPTO_PUBLICKEYBYTES,
+            PQCLEAN_SPHINCSSHA256128FSIMPLE_CRYPTO_BYTES) {}
 
   ~SphincsSHA256128FSimplePqclean() override = default;
 
   int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
            const uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSSHA256128FSIMPLE_AVX2_crypto_sign_signature(
+    return PQCLEAN_SPHINCSSHA256128FSIMPLE_crypto_sign_signature(
         sig, siglen, m, mlen, sk);
   }
 
   int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
              const uint8_t *pk) const override {
-    return PQCLEAN_SPHINCSSHA256128FSIMPLE_AVX2_crypto_sign_verify(sig, siglen,
+    return PQCLEAN_SPHINCSSHA256128FSIMPLE_crypto_sign_verify(sig, siglen,
                                                                    m, mlen, pk);
   }
 
   int Keygen(uint8_t *pk, uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSSHA256128FSIMPLE_AVX2_crypto_sign_keypair(pk, sk);
+    return PQCLEAN_SPHINCSSHA256128FSIMPLE_crypto_sign_keypair(pk, sk);
   }
 };
 
@@ -463,25 +463,25 @@ class SphincsSHA256128SSimplePqclean : public SphincsHelperPqclean {
  public:
   SphincsSHA256128SSimplePqclean()
       : SphincsHelperPqclean(
-            PQCLEAN_SPHINCSSHA256128SSIMPLE_AVX2_CRYPTO_PUBLICKEYBYTES,
-            PQCLEAN_SPHINCSSHA256128SSIMPLE_AVX2_CRYPTO_BYTES) {}
+            PQCLEAN_SPHINCSSHA256128SSIMPLE_CRYPTO_PUBLICKEYBYTES,
+            PQCLEAN_SPHINCSSHA256128SSIMPLE_CRYPTO_BYTES) {}
 
   ~SphincsSHA256128SSimplePqclean() override = default;
 
   int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
            const uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSSHA256128SSIMPLE_AVX2_crypto_sign_signature(
+    return PQCLEAN_SPHINCSSHA256128SSIMPLE_crypto_sign_signature(
         sig, siglen, m, mlen, sk);
   }
 
   int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
              const uint8_t *pk) const override {
-    return PQCLEAN_SPHINCSSHA256128SSIMPLE_AVX2_crypto_sign_verify(sig, siglen,
+    return PQCLEAN_SPHINCSSHA256128SSIMPLE_crypto_sign_verify(sig, siglen,
                                                                    m, mlen, pk);
   }
 
   int Keygen(uint8_t *pk, uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSSHA256128SSIMPLE_AVX2_crypto_sign_keypair(pk, sk);
+    return PQCLEAN_SPHINCSSHA256128SSIMPLE_crypto_sign_keypair(pk, sk);
   }
 };
 
@@ -489,25 +489,25 @@ class SphincsSHA256192FRobustPqclean : public SphincsHelperPqclean {
  public:
   SphincsSHA256192FRobustPqclean()
       : SphincsHelperPqclean(
-            PQCLEAN_SPHINCSSHA256192FROBUST_AVX2_CRYPTO_PUBLICKEYBYTES,
-            PQCLEAN_SPHINCSSHA256192FROBUST_AVX2_CRYPTO_BYTES) {}
+            PQCLEAN_SPHINCSSHA256192FROBUST_CRYPTO_PUBLICKEYBYTES,
+            PQCLEAN_SPHINCSSHA256192FROBUST_CRYPTO_BYTES) {}
 
   ~SphincsSHA256192FRobustPqclean() override = default;
 
   int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
            const uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSSHA256192FROBUST_AVX2_crypto_sign_signature(
+    return PQCLEAN_SPHINCSSHA256192FROBUST_crypto_sign_signature(
         sig, siglen, m, mlen, sk);
   }
 
   int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
              const uint8_t *pk) const override {
-    return PQCLEAN_SPHINCSSHA256192FROBUST_AVX2_crypto_sign_verify(sig, siglen,
+    return PQCLEAN_SPHINCSSHA256192FROBUST_crypto_sign_verify(sig, siglen,
                                                                    m, mlen, pk);
   }
 
   int Keygen(uint8_t *pk, uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSSHA256192FROBUST_AVX2_crypto_sign_keypair(pk, sk);
+    return PQCLEAN_SPHINCSSHA256192FROBUST_crypto_sign_keypair(pk, sk);
   }
 };
 
@@ -515,25 +515,25 @@ class SphincsSHA256192SRobustPqclean : public SphincsHelperPqclean {
  public:
   SphincsSHA256192SRobustPqclean()
       : SphincsHelperPqclean(
-            PQCLEAN_SPHINCSSHA256192SROBUST_AVX2_CRYPTO_PUBLICKEYBYTES,
-            PQCLEAN_SPHINCSSHA256192SROBUST_AVX2_CRYPTO_BYTES) {}
+            PQCLEAN_SPHINCSSHA256192SROBUST_CRYPTO_PUBLICKEYBYTES,
+            PQCLEAN_SPHINCSSHA256192SROBUST_CRYPTO_BYTES) {}
 
   ~SphincsSHA256192SRobustPqclean() override = default;
 
   int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
            const uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSSHA256192SROBUST_AVX2_crypto_sign_signature(
+    return PQCLEAN_SPHINCSSHA256192SROBUST_crypto_sign_signature(
         sig, siglen, m, mlen, sk);
   }
 
   int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
              const uint8_t *pk) const override {
-    return PQCLEAN_SPHINCSSHA256192SROBUST_AVX2_crypto_sign_verify(sig, siglen,
+    return PQCLEAN_SPHINCSSHA256192SROBUST_crypto_sign_verify(sig, siglen,
                                                                    m, mlen, pk);
   }
 
   int Keygen(uint8_t *pk, uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSSHA256192SROBUST_AVX2_crypto_sign_keypair(pk, sk);
+    return PQCLEAN_SPHINCSSHA256192SROBUST_crypto_sign_keypair(pk, sk);
   }
 };
 
@@ -541,25 +541,25 @@ class SphincsSHA256192FSimplePqclean : public SphincsHelperPqclean {
  public:
   SphincsSHA256192FSimplePqclean()
       : SphincsHelperPqclean(
-            PQCLEAN_SPHINCSSHA256192FSIMPLE_AVX2_CRYPTO_PUBLICKEYBYTES,
-            PQCLEAN_SPHINCSSHA256192FSIMPLE_AVX2_CRYPTO_BYTES) {}
+            PQCLEAN_SPHINCSSHA256192FSIMPLE_CRYPTO_PUBLICKEYBYTES,
+            PQCLEAN_SPHINCSSHA256192FSIMPLE_CRYPTO_BYTES) {}
 
   ~SphincsSHA256192FSimplePqclean() override = default;
 
   int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
            const uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSSHA256192FSIMPLE_AVX2_crypto_sign_signature(
+    return PQCLEAN_SPHINCSSHA256192FSIMPLE_crypto_sign_signature(
         sig, siglen, m, mlen, sk);
   }
 
   int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
              const uint8_t *pk) const override {
-    return PQCLEAN_SPHINCSSHA256192FSIMPLE_AVX2_crypto_sign_verify(sig, siglen,
+    return PQCLEAN_SPHINCSSHA256192FSIMPLE_crypto_sign_verify(sig, siglen,
                                                                    m, mlen, pk);
   }
 
   int Keygen(uint8_t *pk, uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSSHA256192FSIMPLE_AVX2_crypto_sign_keypair(pk, sk);
+    return PQCLEAN_SPHINCSSHA256192FSIMPLE_crypto_sign_keypair(pk, sk);
   }
 };
 
@@ -567,25 +567,25 @@ class SphincsSHA256192SSimplePqclean : public SphincsHelperPqclean {
  public:
   SphincsSHA256192SSimplePqclean()
       : SphincsHelperPqclean(
-            PQCLEAN_SPHINCSSHA256192SSIMPLE_AVX2_CRYPTO_PUBLICKEYBYTES,
-            PQCLEAN_SPHINCSSHA256192SSIMPLE_AVX2_CRYPTO_BYTES) {}
+            PQCLEAN_SPHINCSSHA256192SSIMPLE_CRYPTO_PUBLICKEYBYTES,
+            PQCLEAN_SPHINCSSHA256192SSIMPLE_CRYPTO_BYTES) {}
 
   ~SphincsSHA256192SSimplePqclean() override = default;
 
   int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
            const uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSSHA256192SSIMPLE_AVX2_crypto_sign_signature(
+    return PQCLEAN_SPHINCSSHA256192SSIMPLE_crypto_sign_signature(
         sig, siglen, m, mlen, sk);
   }
 
   int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
              const uint8_t *pk) const override {
-    return PQCLEAN_SPHINCSSHA256192SSIMPLE_AVX2_crypto_sign_verify(sig, siglen,
+    return PQCLEAN_SPHINCSSHA256192SSIMPLE_crypto_sign_verify(sig, siglen,
                                                                    m, mlen, pk);
   }
 
   int Keygen(uint8_t *pk, uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSSHA256192SSIMPLE_AVX2_crypto_sign_keypair(pk, sk);
+    return PQCLEAN_SPHINCSSHA256192SSIMPLE_crypto_sign_keypair(pk, sk);
   }
 };
 
@@ -593,25 +593,25 @@ class SphincsSHA256256FRobustPqclean : public SphincsHelperPqclean {
  public:
   SphincsSHA256256FRobustPqclean()
       : SphincsHelperPqclean(
-            PQCLEAN_SPHINCSSHA256256FROBUST_AVX2_CRYPTO_PUBLICKEYBYTES,
-            PQCLEAN_SPHINCSSHA256256FROBUST_AVX2_CRYPTO_BYTES) {}
+            PQCLEAN_SPHINCSSHA256256FROBUST_CRYPTO_PUBLICKEYBYTES,
+            PQCLEAN_SPHINCSSHA256256FROBUST_CRYPTO_BYTES) {}
 
   ~SphincsSHA256256FRobustPqclean() override = default;
 
   int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
            const uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSSHA256256FROBUST_AVX2_crypto_sign_signature(
+    return PQCLEAN_SPHINCSSHA256256FROBUST_crypto_sign_signature(
         sig, siglen, m, mlen, sk);
   }
 
   int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
              const uint8_t *pk) const override {
-    return PQCLEAN_SPHINCSSHA256256FROBUST_AVX2_crypto_sign_verify(sig, siglen,
+    return PQCLEAN_SPHINCSSHA256256FROBUST_crypto_sign_verify(sig, siglen,
                                                                    m, mlen, pk);
   }
 
   int Keygen(uint8_t *pk, uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSSHA256256FROBUST_AVX2_crypto_sign_keypair(pk, sk);
+    return PQCLEAN_SPHINCSSHA256256FROBUST_crypto_sign_keypair(pk, sk);
   }
 };
 
@@ -619,25 +619,25 @@ class SphincsSHA256256SRobustPqclean : public SphincsHelperPqclean {
  public:
   SphincsSHA256256SRobustPqclean()
       : SphincsHelperPqclean(
-            PQCLEAN_SPHINCSSHA256256SROBUST_AVX2_CRYPTO_PUBLICKEYBYTES,
-            PQCLEAN_SPHINCSSHA256256SROBUST_AVX2_CRYPTO_BYTES) {}
+            PQCLEAN_SPHINCSSHA256256SROBUST_CRYPTO_PUBLICKEYBYTES,
+            PQCLEAN_SPHINCSSHA256256SROBUST_CRYPTO_BYTES) {}
 
   ~SphincsSHA256256SRobustPqclean() override = default;
 
   int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
            const uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSSHA256256SROBUST_AVX2_crypto_sign_signature(
+    return PQCLEAN_SPHINCSSHA256256SROBUST_crypto_sign_signature(
         sig, siglen, m, mlen, sk);
   }
 
   int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
              const uint8_t *pk) const override {
-    return PQCLEAN_SPHINCSSHA256256SROBUST_AVX2_crypto_sign_verify(sig, siglen,
+    return PQCLEAN_SPHINCSSHA256256SROBUST_crypto_sign_verify(sig, siglen,
                                                                    m, mlen, pk);
   }
 
   int Keygen(uint8_t *pk, uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSSHA256256SROBUST_AVX2_crypto_sign_keypair(pk, sk);
+    return PQCLEAN_SPHINCSSHA256256SROBUST_crypto_sign_keypair(pk, sk);
   }
 };
 
@@ -645,25 +645,25 @@ class SphincsSHA256256FSimplePqclean : public SphincsHelperPqclean {
  public:
   SphincsSHA256256FSimplePqclean()
       : SphincsHelperPqclean(
-            PQCLEAN_SPHINCSSHA256256FSIMPLE_AVX2_CRYPTO_PUBLICKEYBYTES,
-            PQCLEAN_SPHINCSSHA256256FSIMPLE_AVX2_CRYPTO_BYTES) {}
+            PQCLEAN_SPHINCSSHA256256FSIMPLE_CRYPTO_PUBLICKEYBYTES,
+            PQCLEAN_SPHINCSSHA256256FSIMPLE_CRYPTO_BYTES) {}
 
   ~SphincsSHA256256FSimplePqclean() override = default;
 
   int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
            const uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSSHA256256FSIMPLE_AVX2_crypto_sign_signature(
+    return PQCLEAN_SPHINCSSHA256256FSIMPLE_crypto_sign_signature(
         sig, siglen, m, mlen, sk);
   }
 
   int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
              const uint8_t *pk) const override {
-    return PQCLEAN_SPHINCSSHA256256FSIMPLE_AVX2_crypto_sign_verify(sig, siglen,
+    return PQCLEAN_SPHINCSSHA256256FSIMPLE_crypto_sign_verify(sig, siglen,
                                                                    m, mlen, pk);
   }
 
   int Keygen(uint8_t *pk, uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSSHA256256FSIMPLE_AVX2_crypto_sign_keypair(pk, sk);
+    return PQCLEAN_SPHINCSSHA256256FSIMPLE_crypto_sign_keypair(pk, sk);
   }
 };
 
@@ -671,25 +671,25 @@ class SphincsSHA256256SSimplePqclean : public SphincsHelperPqclean {
  public:
   SphincsSHA256256SSimplePqclean()
       : SphincsHelperPqclean(
-            PQCLEAN_SPHINCSSHA256256SSIMPLE_AVX2_CRYPTO_PUBLICKEYBYTES,
-            PQCLEAN_SPHINCSSHA256256SSIMPLE_AVX2_CRYPTO_BYTES) {}
+            PQCLEAN_SPHINCSSHA256256SSIMPLE_CRYPTO_PUBLICKEYBYTES,
+            PQCLEAN_SPHINCSSHA256256SSIMPLE_CRYPTO_BYTES) {}
 
   ~SphincsSHA256256SSimplePqclean() override = default;
 
   int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
            const uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSSHA256256SSIMPLE_AVX2_crypto_sign_signature(
+    return PQCLEAN_SPHINCSSHA256256SSIMPLE_crypto_sign_signature(
         sig, siglen, m, mlen, sk);
   }
 
   int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
              const uint8_t *pk) const override {
-    return PQCLEAN_SPHINCSSHA256256SSIMPLE_AVX2_crypto_sign_verify(sig, siglen,
+    return PQCLEAN_SPHINCSSHA256256SSIMPLE_crypto_sign_verify(sig, siglen,
                                                                    m, mlen, pk);
   }
 
   int Keygen(uint8_t *pk, uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSSHA256256SSIMPLE_AVX2_crypto_sign_keypair(pk, sk);
+    return PQCLEAN_SPHINCSSHA256256SSIMPLE_crypto_sign_keypair(pk, sk);
   }
 };
 
@@ -697,25 +697,25 @@ class SphincsSHAKE256128FRobustPqclean : public SphincsHelperPqclean {
  public:
   SphincsSHAKE256128FRobustPqclean()
       : SphincsHelperPqclean(
-            PQCLEAN_SPHINCSSHAKE256128FROBUST_AVX2_CRYPTO_PUBLICKEYBYTES,
-            PQCLEAN_SPHINCSSHAKE256128FROBUST_AVX2_CRYPTO_BYTES) {}
+            PQCLEAN_SPHINCSSHAKE256128FROBUST_CRYPTO_PUBLICKEYBYTES,
+            PQCLEAN_SPHINCSSHAKE256128FROBUST_CRYPTO_BYTES) {}
 
   ~SphincsSHAKE256128FRobustPqclean() override = default;
 
   int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
            const uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSSHAKE256128FROBUST_AVX2_crypto_sign_signature(
+    return PQCLEAN_SPHINCSSHAKE256128FROBUST_crypto_sign_signature(
         sig, siglen, m, mlen, sk);
   }
 
   int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
              const uint8_t *pk) const override {
-    return PQCLEAN_SPHINCSSHAKE256128FROBUST_AVX2_crypto_sign_verify(
+    return PQCLEAN_SPHINCSSHAKE256128FROBUST_crypto_sign_verify(
         sig, siglen, m, mlen, pk);
   }
 
   int Keygen(uint8_t *pk, uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSSHAKE256128FROBUST_AVX2_crypto_sign_keypair(pk, sk);
+    return PQCLEAN_SPHINCSSHAKE256128FROBUST_crypto_sign_keypair(pk, sk);
   }
 };
 
@@ -723,25 +723,25 @@ class SphincsSHAKE256128SRobustPqclean : public SphincsHelperPqclean {
  public:
   SphincsSHAKE256128SRobustPqclean()
       : SphincsHelperPqclean(
-            PQCLEAN_SPHINCSSHAKE256128SROBUST_AVX2_CRYPTO_PUBLICKEYBYTES,
-            PQCLEAN_SPHINCSSHAKE256128SROBUST_AVX2_CRYPTO_BYTES) {}
+            PQCLEAN_SPHINCSSHAKE256128SROBUST_CRYPTO_PUBLICKEYBYTES,
+            PQCLEAN_SPHINCSSHAKE256128SROBUST_CRYPTO_BYTES) {}
 
   ~SphincsSHAKE256128SRobustPqclean() override = default;
 
   int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
            const uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSSHAKE256128SROBUST_AVX2_crypto_sign_signature(
+    return PQCLEAN_SPHINCSSHAKE256128SROBUST_crypto_sign_signature(
         sig, siglen, m, mlen, sk);
   }
 
   int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
              const uint8_t *pk) const override {
-    return PQCLEAN_SPHINCSSHAKE256128SROBUST_AVX2_crypto_sign_verify(
+    return PQCLEAN_SPHINCSSHAKE256128SROBUST_crypto_sign_verify(
         sig, siglen, m, mlen, pk);
   }
 
   int Keygen(uint8_t *pk, uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSSHAKE256128SROBUST_AVX2_crypto_sign_keypair(pk, sk);
+    return PQCLEAN_SPHINCSSHAKE256128SROBUST_crypto_sign_keypair(pk, sk);
   }
 };
 
@@ -749,25 +749,25 @@ class SphincsSHAKE256128FSimplePqclean : public SphincsHelperPqclean {
  public:
   SphincsSHAKE256128FSimplePqclean()
       : SphincsHelperPqclean(
-            PQCLEAN_SPHINCSSHAKE256128FSIMPLE_AVX2_CRYPTO_PUBLICKEYBYTES,
-            PQCLEAN_SPHINCSSHAKE256128FSIMPLE_AVX2_CRYPTO_BYTES) {}
+            PQCLEAN_SPHINCSSHAKE256128FSIMPLE_CRYPTO_PUBLICKEYBYTES,
+            PQCLEAN_SPHINCSSHAKE256128FSIMPLE_CRYPTO_BYTES) {}
 
   ~SphincsSHAKE256128FSimplePqclean() override = default;
 
   int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
            const uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSSHAKE256128FSIMPLE_AVX2_crypto_sign_signature(
+    return PQCLEAN_SPHINCSSHAKE256128FSIMPLE_crypto_sign_signature(
         sig, siglen, m, mlen, sk);
   }
 
   int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
              const uint8_t *pk) const override {
-    return PQCLEAN_SPHINCSSHAKE256128FSIMPLE_AVX2_crypto_sign_verify(
+    return PQCLEAN_SPHINCSSHAKE256128FSIMPLE_crypto_sign_verify(
         sig, siglen, m, mlen, pk);
   }
 
   int Keygen(uint8_t *pk, uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSSHAKE256128FSIMPLE_AVX2_crypto_sign_keypair(pk, sk);
+    return PQCLEAN_SPHINCSSHAKE256128FSIMPLE_crypto_sign_keypair(pk, sk);
   }
 };
 
@@ -775,25 +775,25 @@ class SphincsSHAKE256128SSimplePqclean : public SphincsHelperPqclean {
  public:
   SphincsSHAKE256128SSimplePqclean()
       : SphincsHelperPqclean(
-            PQCLEAN_SPHINCSSHAKE256128SSIMPLE_AVX2_CRYPTO_PUBLICKEYBYTES,
-            PQCLEAN_SPHINCSSHAKE256128SSIMPLE_AVX2_CRYPTO_BYTES) {}
+            PQCLEAN_SPHINCSSHAKE256128SSIMPLE_CRYPTO_PUBLICKEYBYTES,
+            PQCLEAN_SPHINCSSHAKE256128SSIMPLE_CRYPTO_BYTES) {}
 
   ~SphincsSHAKE256128SSimplePqclean() override = default;
 
   int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
            const uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSSHAKE256128SSIMPLE_AVX2_crypto_sign_signature(
+    return PQCLEAN_SPHINCSSHAKE256128SSIMPLE_crypto_sign_signature(
         sig, siglen, m, mlen, sk);
   }
 
   int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
              const uint8_t *pk) const override {
-    return PQCLEAN_SPHINCSSHAKE256128SSIMPLE_AVX2_crypto_sign_verify(
+    return PQCLEAN_SPHINCSSHAKE256128SSIMPLE_crypto_sign_verify(
         sig, siglen, m, mlen, pk);
   }
 
   int Keygen(uint8_t *pk, uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSSHAKE256128SSIMPLE_AVX2_crypto_sign_keypair(pk, sk);
+    return PQCLEAN_SPHINCSSHAKE256128SSIMPLE_crypto_sign_keypair(pk, sk);
   }
 };
 
@@ -801,25 +801,25 @@ class SphincsSHAKE256192FRobustPqclean : public SphincsHelperPqclean {
  public:
   SphincsSHAKE256192FRobustPqclean()
       : SphincsHelperPqclean(
-            PQCLEAN_SPHINCSSHAKE256192FROBUST_AVX2_CRYPTO_PUBLICKEYBYTES,
-            PQCLEAN_SPHINCSSHAKE256192FROBUST_AVX2_CRYPTO_BYTES) {}
+            PQCLEAN_SPHINCSSHAKE256192FROBUST_CRYPTO_PUBLICKEYBYTES,
+            PQCLEAN_SPHINCSSHAKE256192FROBUST_CRYPTO_BYTES) {}
 
   ~SphincsSHAKE256192FRobustPqclean() override = default;
 
   int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
            const uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSSHAKE256192FROBUST_AVX2_crypto_sign_signature(
+    return PQCLEAN_SPHINCSSHAKE256192FROBUST_crypto_sign_signature(
         sig, siglen, m, mlen, sk);
   }
 
   int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
              const uint8_t *pk) const override {
-    return PQCLEAN_SPHINCSSHAKE256192FROBUST_AVX2_crypto_sign_verify(
+    return PQCLEAN_SPHINCSSHAKE256192FROBUST_crypto_sign_verify(
         sig, siglen, m, mlen, pk);
   }
 
   int Keygen(uint8_t *pk, uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSSHAKE256192FROBUST_AVX2_crypto_sign_keypair(pk, sk);
+    return PQCLEAN_SPHINCSSHAKE256192FROBUST_crypto_sign_keypair(pk, sk);
   }
 };
 
@@ -827,25 +827,25 @@ class SphincsSHAKE256192SRobustPqclean : public SphincsHelperPqclean {
  public:
   SphincsSHAKE256192SRobustPqclean()
       : SphincsHelperPqclean(
-            PQCLEAN_SPHINCSSHAKE256192SROBUST_AVX2_CRYPTO_PUBLICKEYBYTES,
-            PQCLEAN_SPHINCSSHAKE256192SROBUST_AVX2_CRYPTO_BYTES) {}
+            PQCLEAN_SPHINCSSHAKE256192SROBUST_CRYPTO_PUBLICKEYBYTES,
+            PQCLEAN_SPHINCSSHAKE256192SROBUST_CRYPTO_BYTES) {}
 
   ~SphincsSHAKE256192SRobustPqclean() override = default;
 
   int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
            const uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSSHAKE256192SROBUST_AVX2_crypto_sign_signature(
+    return PQCLEAN_SPHINCSSHAKE256192SROBUST_crypto_sign_signature(
         sig, siglen, m, mlen, sk);
   }
 
   int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
              const uint8_t *pk) const override {
-    return PQCLEAN_SPHINCSSHAKE256192SROBUST_AVX2_crypto_sign_verify(
+    return PQCLEAN_SPHINCSSHAKE256192SROBUST_crypto_sign_verify(
         sig, siglen, m, mlen, pk);
   }
 
   int Keygen(uint8_t *pk, uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSSHAKE256192SROBUST_AVX2_crypto_sign_keypair(pk, sk);
+    return PQCLEAN_SPHINCSSHAKE256192SROBUST_crypto_sign_keypair(pk, sk);
   }
 };
 
@@ -853,25 +853,25 @@ class SphincsSHAKE256192FSimplePqclean : public SphincsHelperPqclean {
  public:
   SphincsSHAKE256192FSimplePqclean()
       : SphincsHelperPqclean(
-            PQCLEAN_SPHINCSSHAKE256192FSIMPLE_AVX2_CRYPTO_PUBLICKEYBYTES,
-            PQCLEAN_SPHINCSSHAKE256192FSIMPLE_AVX2_CRYPTO_BYTES) {}
+            PQCLEAN_SPHINCSSHAKE256192FSIMPLE_CRYPTO_PUBLICKEYBYTES,
+            PQCLEAN_SPHINCSSHAKE256192FSIMPLE_CRYPTO_BYTES) {}
 
   ~SphincsSHAKE256192FSimplePqclean() override = default;
 
   int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
            const uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSSHAKE256192FSIMPLE_AVX2_crypto_sign_signature(
+    return PQCLEAN_SPHINCSSHAKE256192FSIMPLE_crypto_sign_signature(
         sig, siglen, m, mlen, sk);
   }
 
   int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
              const uint8_t *pk) const override {
-    return PQCLEAN_SPHINCSSHAKE256192FSIMPLE_AVX2_crypto_sign_verify(
+    return PQCLEAN_SPHINCSSHAKE256192FSIMPLE_crypto_sign_verify(
         sig, siglen, m, mlen, pk);
   }
 
   int Keygen(uint8_t *pk, uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSSHAKE256192FSIMPLE_AVX2_crypto_sign_keypair(pk, sk);
+    return PQCLEAN_SPHINCSSHAKE256192FSIMPLE_crypto_sign_keypair(pk, sk);
   }
 };
 
@@ -879,25 +879,25 @@ class SphincsSHAKE256192SSimplePqclean : public SphincsHelperPqclean {
  public:
   SphincsSHAKE256192SSimplePqclean()
       : SphincsHelperPqclean(
-            PQCLEAN_SPHINCSSHAKE256192SSIMPLE_AVX2_CRYPTO_PUBLICKEYBYTES,
-            PQCLEAN_SPHINCSSHAKE256192SSIMPLE_AVX2_CRYPTO_BYTES) {}
+            PQCLEAN_SPHINCSSHAKE256192SSIMPLE_CRYPTO_PUBLICKEYBYTES,
+            PQCLEAN_SPHINCSSHAKE256192SSIMPLE_CRYPTO_BYTES) {}
 
   ~SphincsSHAKE256192SSimplePqclean() override = default;
 
   int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
            const uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSSHAKE256192SSIMPLE_AVX2_crypto_sign_signature(
+    return PQCLEAN_SPHINCSSHAKE256192SSIMPLE_crypto_sign_signature(
         sig, siglen, m, mlen, sk);
   }
 
   int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
              const uint8_t *pk) const override {
-    return PQCLEAN_SPHINCSSHAKE256192SSIMPLE_AVX2_crypto_sign_verify(
+    return PQCLEAN_SPHINCSSHAKE256192SSIMPLE_crypto_sign_verify(
         sig, siglen, m, mlen, pk);
   }
 
   int Keygen(uint8_t *pk, uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSSHAKE256192SSIMPLE_AVX2_crypto_sign_keypair(pk, sk);
+    return PQCLEAN_SPHINCSSHAKE256192SSIMPLE_crypto_sign_keypair(pk, sk);
   }
 };
 
@@ -905,25 +905,25 @@ class SphincsSHAKE256256FRobustPqclean : public SphincsHelperPqclean {
  public:
   SphincsSHAKE256256FRobustPqclean()
       : SphincsHelperPqclean(
-            PQCLEAN_SPHINCSSHAKE256256FROBUST_AVX2_CRYPTO_PUBLICKEYBYTES,
-            PQCLEAN_SPHINCSSHAKE256256FROBUST_AVX2_CRYPTO_BYTES) {}
+            PQCLEAN_SPHINCSSHAKE256256FROBUST_CRYPTO_PUBLICKEYBYTES,
+            PQCLEAN_SPHINCSSHAKE256256FROBUST_CRYPTO_BYTES) {}
 
   ~SphincsSHAKE256256FRobustPqclean() override = default;
 
   int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
            const uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSSHAKE256256FROBUST_AVX2_crypto_sign_signature(
+    return PQCLEAN_SPHINCSSHAKE256256FROBUST_crypto_sign_signature(
         sig, siglen, m, mlen, sk);
   }
 
   int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
              const uint8_t *pk) const override {
-    return PQCLEAN_SPHINCSSHAKE256256FROBUST_AVX2_crypto_sign_verify(
+    return PQCLEAN_SPHINCSSHAKE256256FROBUST_crypto_sign_verify(
         sig, siglen, m, mlen, pk);
   }
 
   int Keygen(uint8_t *pk, uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSSHAKE256256FROBUST_AVX2_crypto_sign_keypair(pk, sk);
+    return PQCLEAN_SPHINCSSHAKE256256FROBUST_crypto_sign_keypair(pk, sk);
   }
 };
 
@@ -931,25 +931,25 @@ class SphincsSHAKE256256SRobustPqclean : public SphincsHelperPqclean {
  public:
   SphincsSHAKE256256SRobustPqclean()
       : SphincsHelperPqclean(
-            PQCLEAN_SPHINCSSHAKE256256SROBUST_AVX2_CRYPTO_PUBLICKEYBYTES,
-            PQCLEAN_SPHINCSSHAKE256256SROBUST_AVX2_CRYPTO_BYTES) {}
+            PQCLEAN_SPHINCSSHAKE256256SROBUST_CRYPTO_PUBLICKEYBYTES,
+            PQCLEAN_SPHINCSSHAKE256256SROBUST_CRYPTO_BYTES) {}
 
   ~SphincsSHAKE256256SRobustPqclean() override = default;
 
   int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
            const uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSSHAKE256256SROBUST_AVX2_crypto_sign_signature(
+    return PQCLEAN_SPHINCSSHAKE256256SROBUST_crypto_sign_signature(
         sig, siglen, m, mlen, sk);
   }
 
   int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
              const uint8_t *pk) const override {
-    return PQCLEAN_SPHINCSSHAKE256256SROBUST_AVX2_crypto_sign_verify(
+    return PQCLEAN_SPHINCSSHAKE256256SROBUST_crypto_sign_verify(
         sig, siglen, m, mlen, pk);
   }
 
   int Keygen(uint8_t *pk, uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSSHAKE256256SROBUST_AVX2_crypto_sign_keypair(pk, sk);
+    return PQCLEAN_SPHINCSSHAKE256256SROBUST_crypto_sign_keypair(pk, sk);
   }
 };
 
@@ -957,25 +957,25 @@ class SphincsSHAKE256256FSimplePqclean : public SphincsHelperPqclean {
  public:
   SphincsSHAKE256256FSimplePqclean()
       : SphincsHelperPqclean(
-            PQCLEAN_SPHINCSSHAKE256256FSIMPLE_AVX2_CRYPTO_PUBLICKEYBYTES,
-            PQCLEAN_SPHINCSSHAKE256256FSIMPLE_AVX2_CRYPTO_BYTES) {}
+            PQCLEAN_SPHINCSSHAKE256256FSIMPLE_CRYPTO_PUBLICKEYBYTES,
+            PQCLEAN_SPHINCSSHAKE256256FSIMPLE_CRYPTO_BYTES) {}
 
   ~SphincsSHAKE256256FSimplePqclean() override = default;
 
   int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
            const uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSSHAKE256256FSIMPLE_AVX2_crypto_sign_signature(
+    return PQCLEAN_SPHINCSSHAKE256256FSIMPLE_crypto_sign_signature(
         sig, siglen, m, mlen, sk);
   }
 
   int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
              const uint8_t *pk) const override {
-    return PQCLEAN_SPHINCSSHAKE256256FSIMPLE_AVX2_crypto_sign_verify(
+    return PQCLEAN_SPHINCSSHAKE256256FSIMPLE_crypto_sign_verify(
         sig, siglen, m, mlen, pk);
   }
 
   int Keygen(uint8_t *pk, uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSSHAKE256256FSIMPLE_AVX2_crypto_sign_keypair(pk, sk);
+    return PQCLEAN_SPHINCSSHAKE256256FSIMPLE_crypto_sign_keypair(pk, sk);
   }
 };
 
@@ -983,25 +983,25 @@ class SphincsSHAKE256256SSimplePqclean : public SphincsHelperPqclean {
  public:
   SphincsSHAKE256256SSimplePqclean()
       : SphincsHelperPqclean(
-            PQCLEAN_SPHINCSSHAKE256256SSIMPLE_AVX2_CRYPTO_PUBLICKEYBYTES,
-            PQCLEAN_SPHINCSSHAKE256256SSIMPLE_AVX2_CRYPTO_BYTES) {}
+            PQCLEAN_SPHINCSSHAKE256256SSIMPLE_CRYPTO_PUBLICKEYBYTES,
+            PQCLEAN_SPHINCSSHAKE256256SSIMPLE_CRYPTO_BYTES) {}
 
   ~SphincsSHAKE256256SSimplePqclean() override = default;
 
   int Sign(uint8_t *sig, size_t *siglen, const uint8_t *m, size_t mlen,
            const uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSSHAKE256256SSIMPLE_AVX2_crypto_sign_signature(
+    return PQCLEAN_SPHINCSSHAKE256256SSIMPLE_crypto_sign_signature(
         sig, siglen, m, mlen, sk);
   }
 
   int Verify(const uint8_t *sig, size_t siglen, const uint8_t *m, size_t mlen,
              const uint8_t *pk) const override {
-    return PQCLEAN_SPHINCSSHAKE256256SSIMPLE_AVX2_crypto_sign_verify(
+    return PQCLEAN_SPHINCSSHAKE256256SSIMPLE_crypto_sign_verify(
         sig, siglen, m, mlen, pk);
   }
 
   int Keygen(uint8_t *pk, uint8_t *sk) const override {
-    return PQCLEAN_SPHINCSSHAKE256256SSIMPLE_AVX2_crypto_sign_keypair(pk, sk);
+    return PQCLEAN_SPHINCSSHAKE256256SSIMPLE_crypto_sign_keypair(pk, sk);
   }
 };
 
diff --git a/cc/experimental/pqcrypto/signature/subtle/sphincs_sign_test.cc b/cc/experimental/pqcrypto/signature/subtle/sphincs_sign_test.cc
index 9126545b7..ddb36e8c7 100644
--- a/cc/experimental/pqcrypto/signature/subtle/sphincs_sign_test.cc
+++ b/cc/experimental/pqcrypto/signature/subtle/sphincs_sign_test.cc
@@ -32,42 +32,42 @@
 #include "tink/util/test_matchers.h"
 
 extern "C" {
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-128f-robust/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-128f-simple/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-128s-robust/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-128s-simple/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-192f-robust/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-192f-simple/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-192s-robust/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-192s-simple/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-256f-robust/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-256f-simple/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-256s-robust/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-256s-simple/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-128f-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-128f-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-128s-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-128s-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-192f-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-192f-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-192s-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-192s-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-256f-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-256f-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-256s-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-256s-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-128f-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-128f-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-128s-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-128s-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-192f-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-192f-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-192s-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-192s-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-256f-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-256f-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-256s-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-256s-simple/avx2/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-128f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-128f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-128s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-128s-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-192f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-192f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-192s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-192s-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-256f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-256f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-256s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-256s-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-128f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-128f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-128s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-128s-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-192f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-192f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-192s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-192s-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-256f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-256f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-256s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-256s-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-128f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-128f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-128s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-128s-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-192f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-192f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-192s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-192s-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-256f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-256f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-256s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-256s-simple/api.h"
 }
 
 namespace crypto {
@@ -199,156 +199,156 @@ INSTANTIATE_TEST_SUITE_P(
     testing::ValuesIn<SphincsTestCase>(
         {{"SPHINCSHARAKA128FROBUST", SphincsHashType::HARAKA,
           SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSHARAKA128FROBUST_AESNI_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSHARAKA128FROBUST_AESNI_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSHARAKA128FROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA128FROBUST_CRYPTO_BYTES},
          {"SPHINCSHARAKA128SROBUST", SphincsHashType::HARAKA,
           SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSHARAKA128SROBUST_AESNI_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSHARAKA128SROBUST_AESNI_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSHARAKA128SROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA128SROBUST_CRYPTO_BYTES},
          {"SPHINCSHARAKA128FSIMPLE", SphincsHashType::HARAKA,
           SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSHARAKA128FSIMPLE_AESNI_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSHARAKA128FSIMPLE_AESNI_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSHARAKA128FSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA128FSIMPLE_CRYPTO_BYTES},
          {"SPHINCSHARAKA128SSIMPLE", SphincsHashType::HARAKA,
           SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSHARAKA128SSIMPLE_AESNI_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSHARAKA128SSIMPLE_AESNI_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSHARAKA128SSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA128SSIMPLE_CRYPTO_BYTES},
 
          {"SPHINCSHARAKA192FROBUST", SphincsHashType::HARAKA,
           SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSHARAKA192FROBUST_AESNI_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSHARAKA192FROBUST_AESNI_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSHARAKA192FROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA192FROBUST_CRYPTO_BYTES},
          {"SPHINCSHARAKA192SROBUST", SphincsHashType::HARAKA,
           SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSHARAKA192SROBUST_AESNI_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSHARAKA192SROBUST_AESNI_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSHARAKA192SROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA192SROBUST_CRYPTO_BYTES},
          {"SPHINCSHARAKA192FSIMPLE", SphincsHashType::HARAKA,
           SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSHARAKA192FSIMPLE_AESNI_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSHARAKA192FSIMPLE_AESNI_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSHARAKA192FSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA192FSIMPLE_CRYPTO_BYTES},
          {"SPHINCSHARAKA192SSIMPLE", SphincsHashType::HARAKA,
           SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSHARAKA192SSIMPLE_AESNI_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSHARAKA192SSIMPLE_AESNI_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSHARAKA192SSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA192SSIMPLE_CRYPTO_BYTES},
 
          {"SPHINCSHARAKA256FROBUST", SphincsHashType::HARAKA,
           SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSHARAKA256FROBUST_AESNI_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSHARAKA256FROBUST_AESNI_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSHARAKA256FROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA256FROBUST_CRYPTO_BYTES},
          {"SPHINCSHARAKA256SROBUST", SphincsHashType::HARAKA,
           SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSHARAKA256SROBUST_AESNI_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSHARAKA256SROBUST_AESNI_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSHARAKA256SROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA256SROBUST_CRYPTO_BYTES},
          {"SPHINCSHARAKA256FSIMPLE", SphincsHashType::HARAKA,
           SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSHARAKA256FSIMPLE_AESNI_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSHARAKA256FSIMPLE_AESNI_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSHARAKA256FSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA256FSIMPLE_CRYPTO_BYTES},
          {"SPHINCSHARAKA256SSIMPLE", SphincsHashType::HARAKA,
           SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSHARAKA256SSIMPLE_AESNI_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSHARAKA256SSIMPLE_AESNI_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSHARAKA256SSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA256SSIMPLE_CRYPTO_BYTES},
 
          {"SPHINCSSHA256128FROBUST", SphincsHashType::SHA256,
           SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHA256128FROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHA256128FROBUST_AVX2_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSSHA256128FROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256128FROBUST_CRYPTO_BYTES},
          {"SPHINCSSHA256128SROBUST", SphincsHashType::SHA256,
           SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHA256128SROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHA256128SROBUST_AVX2_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSSHA256128SROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256128SROBUST_CRYPTO_BYTES},
          {"SPHINCSSHA256128FSIMPLE", SphincsHashType::SHA256,
           SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHA256128FSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHA256128FSIMPLE_AVX2_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSSHA256128FSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256128FSIMPLE_CRYPTO_BYTES},
          {"SPHINCSSHA256128SSIMPLE", SphincsHashType::SHA256,
           SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHA256128SSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHA256128SSIMPLE_AVX2_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSSHA256128SSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256128SSIMPLE_CRYPTO_BYTES},
 
          {"SPHINCSSHA256192FROBUST", SphincsHashType::SHA256,
           SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHA256192FROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHA256192FROBUST_AVX2_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSSHA256192FROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256192FROBUST_CRYPTO_BYTES},
          {"SPHINCSSHA256192SROBUST", SphincsHashType::SHA256,
           SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHA256192SROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHA256192SROBUST_AVX2_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSSHA256192SROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256192SROBUST_CRYPTO_BYTES},
          {"SPHINCSSHA256192FSIMPLE", SphincsHashType::SHA256,
           SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHA256192FSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHA256192FSIMPLE_AVX2_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSSHA256192FSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256192FSIMPLE_CRYPTO_BYTES},
          {"SPHINCSSHA256192SSIMPLE", SphincsHashType::SHA256,
           SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHA256192SSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHA256192SSIMPLE_AVX2_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSSHA256192SSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256192SSIMPLE_CRYPTO_BYTES},
 
          {"SPHINCSSHA256256FROBUST", SphincsHashType::SHA256,
           SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHA256256FROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHA256256FROBUST_AVX2_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSSHA256256FROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256256FROBUST_CRYPTO_BYTES},
          {"SPHINCSSHA256256SROBUST", SphincsHashType::SHA256,
           SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHA256256SROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHA256256SROBUST_AVX2_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSSHA256256SROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256256SROBUST_CRYPTO_BYTES},
          {"SPHINCSSHA256256FSIMPLE", SphincsHashType::SHA256,
           SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHA256256FSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHA256256FSIMPLE_AVX2_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSSHA256256FSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256256FSIMPLE_CRYPTO_BYTES},
          {"SPHINCSSHA256256SSIMPLE", SphincsHashType::SHA256,
           SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHA256256SSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHA256256SSIMPLE_AVX2_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSSHA256256SSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256256SSIMPLE_CRYPTO_BYTES},
 
          {"SPHINCSSHAKE256128FROBUST", SphincsHashType::SHAKE256,
           SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHAKE256128FROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHAKE256128FROBUST_AVX2_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSSHAKE256128FROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256128FROBUST_CRYPTO_BYTES},
          {"SPHINCSSHAKE256128SROBUST", SphincsHashType::SHAKE256,
           SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHAKE256128SROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHAKE256128SROBUST_AVX2_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSSHAKE256128SROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256128SROBUST_CRYPTO_BYTES},
          {"SPHINCSSHAKE256128FSIMPLE", SphincsHashType::SHAKE256,
           SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHAKE256128FSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHAKE256128FSIMPLE_AVX2_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSSHAKE256128FSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256128FSIMPLE_CRYPTO_BYTES},
          {"SPHINCSSHAKE256128SSIMPLE", SphincsHashType::SHAKE256,
           SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHAKE256128SSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHAKE256128SSIMPLE_AVX2_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSSHAKE256128SSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256128SSIMPLE_CRYPTO_BYTES},
 
          {"SPHINCSSHAKE256192FROBUST", SphincsHashType::SHAKE256,
           SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHAKE256192FROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHAKE256192FROBUST_AVX2_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSSHAKE256192FROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256192FROBUST_CRYPTO_BYTES},
          {"SPHINCSSHAKE256192SROBUST", SphincsHashType::SHAKE256,
           SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHAKE256192SROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHAKE256192SROBUST_AVX2_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSSHAKE256192SROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256192SROBUST_CRYPTO_BYTES},
          {"SPHINCSSHAKE256192FSIMPLE", SphincsHashType::SHAKE256,
           SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHAKE256192FSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHAKE256192FSIMPLE_AVX2_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSSHAKE256192FSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256192FSIMPLE_CRYPTO_BYTES},
          {"SPHINCSSHAKE256192SSIMPLE", SphincsHashType::SHAKE256,
           SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHAKE256192SSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHAKE256192SSIMPLE_AVX2_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSSHAKE256192SSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256192SSIMPLE_CRYPTO_BYTES},
 
          {"SPHINCSSHAKE256256FROBUST", SphincsHashType::SHAKE256,
           SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHAKE256256FROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHAKE256256FROBUST_AVX2_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSSHAKE256256FROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256256FROBUST_CRYPTO_BYTES},
          {"SPHINCSSHAKE256256SROBUST", SphincsHashType::SHAKE256,
           SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHAKE256256SROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHAKE256256SROBUST_AVX2_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSSHAKE256256SROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256256SROBUST_CRYPTO_BYTES},
          {"SPHINCSSHAKE256256FSIMPLE", SphincsHashType::SHAKE256,
           SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHAKE256256FSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHAKE256256FSIMPLE_AVX2_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSSHAKE256256FSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256256FSIMPLE_CRYPTO_BYTES},
          {"SPHINCSSHAKE256256SSIMPLE", SphincsHashType::SHAKE256,
           SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHAKE256256SSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHAKE256256SSIMPLE_AVX2_CRYPTO_BYTES}}),
+          PQCLEAN_SPHINCSSHAKE256256SSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256256SSIMPLE_CRYPTO_BYTES}}),
     [](const testing::TestParamInfo<SphincsSignTest::ParamType>& info) {
       return info.param.test_name;
     });
diff --git a/cc/experimental/pqcrypto/signature/subtle/sphincs_subtle_utils_test.cc b/cc/experimental/pqcrypto/signature/subtle/sphincs_subtle_utils_test.cc
index a55ccec4f..dca7bd0f1 100644
--- a/cc/experimental/pqcrypto/signature/subtle/sphincs_subtle_utils_test.cc
+++ b/cc/experimental/pqcrypto/signature/subtle/sphincs_subtle_utils_test.cc
@@ -28,42 +28,42 @@
 #include "tink/util/test_matchers.h"
 
 extern "C" {
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-128f-robust/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-128f-simple/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-128s-robust/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-128s-simple/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-192f-robust/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-192f-simple/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-192s-robust/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-192s-simple/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-256f-robust/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-256f-simple/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-256s-robust/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-256s-simple/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-128f-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-128f-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-128s-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-128s-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-192f-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-192f-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-192s-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-192s-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-256f-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-256f-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-256s-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-256s-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-128f-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-128f-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-128s-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-128s-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-192f-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-192f-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-192s-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-192s-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-256f-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-256f-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-256s-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-256s-simple/avx2/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-128f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-128f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-128s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-128s-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-192f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-192f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-192s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-192s-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-256f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-256f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-256s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-256s-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-128f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-128f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-128s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-128s-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-192f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-192f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-192s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-192s-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-256f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-256f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-256s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-256s-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-128f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-128f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-128s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-128s-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-192f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-192f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-192s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-192s-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-256f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-256f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-256s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-256s-simple/api.h"
 }
 
 namespace crypto {
@@ -199,156 +199,156 @@ INSTANTIATE_TEST_SUITE_P(
     testing::ValuesIn<SphincsUtilsTestCase>(
         {{"SPHINCSHARAKA128FROBUST", SphincsHashType::HARAKA,
           SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSHARAKA128FROBUST_AESNI_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSHARAKA128FROBUST_AESNI_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSHARAKA128FROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA128FROBUST_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSHARAKA128SROBUST", SphincsHashType::HARAKA,
           SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSHARAKA128SROBUST_AESNI_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSHARAKA128SROBUST_AESNI_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSHARAKA128SROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA128SROBUST_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSHARAKA128FSIMPLE", SphincsHashType::HARAKA,
           SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSHARAKA128FSIMPLE_AESNI_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSHARAKA128FSIMPLE_AESNI_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSHARAKA128FSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA128FSIMPLE_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSHARAKA128SSIMPLE", SphincsHashType::HARAKA,
           SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSHARAKA128SSIMPLE_AESNI_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSHARAKA128SSIMPLE_AESNI_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSHARAKA128SSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA128SSIMPLE_CRYPTO_PUBLICKEYBYTES},
 
          {"SPHINCSHARAKA192FROBUST", SphincsHashType::HARAKA,
           SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSHARAKA192FROBUST_AESNI_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSHARAKA192FROBUST_AESNI_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSHARAKA192FROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA192FROBUST_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSHARAKA192SROBUST", SphincsHashType::HARAKA,
           SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSHARAKA192SROBUST_AESNI_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSHARAKA192SROBUST_AESNI_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSHARAKA192SROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA192SROBUST_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSHARAKA192FSIMPLE", SphincsHashType::HARAKA,
           SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSHARAKA192FSIMPLE_AESNI_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSHARAKA192FSIMPLE_AESNI_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSHARAKA192FSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA192FSIMPLE_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSHARAKA192SSIMPLE", SphincsHashType::HARAKA,
           SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSHARAKA192SSIMPLE_AESNI_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSHARAKA192SSIMPLE_AESNI_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSHARAKA192SSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA192SSIMPLE_CRYPTO_PUBLICKEYBYTES},
 
          {"SPHINCSHARAKA256FROBUST", SphincsHashType::HARAKA,
           SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSHARAKA256FROBUST_AESNI_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSHARAKA256FROBUST_AESNI_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSHARAKA256FROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA256FROBUST_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSHARAKA256SROBUST", SphincsHashType::HARAKA,
           SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSHARAKA256SROBUST_AESNI_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSHARAKA256SROBUST_AESNI_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSHARAKA256SROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA256SROBUST_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSHARAKA256FSIMPLE", SphincsHashType::HARAKA,
           SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSHARAKA256FSIMPLE_AESNI_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSHARAKA256FSIMPLE_AESNI_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSHARAKA256FSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA256FSIMPLE_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSHARAKA256SSIMPLE", SphincsHashType::HARAKA,
           SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSHARAKA256SSIMPLE_AESNI_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSHARAKA256SSIMPLE_AESNI_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSHARAKA256SSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA256SSIMPLE_CRYPTO_PUBLICKEYBYTES},
 
          {"SPHINCSSHA256128FROBUST", SphincsHashType::SHA256,
           SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHA256128FROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHA256128FROBUST_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHA256128FROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256128FROBUST_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSSHA256128SROBUST", SphincsHashType::SHA256,
           SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHA256128SROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHA256128SROBUST_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHA256128SROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256128SROBUST_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSSHA256128FSIMPLE", SphincsHashType::SHA256,
           SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHA256128FSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHA256128FSIMPLE_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHA256128FSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256128FSIMPLE_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSSHA256128SSIMPLE", SphincsHashType::SHA256,
           SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHA256128SSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHA256128SSIMPLE_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHA256128SSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256128SSIMPLE_CRYPTO_PUBLICKEYBYTES},
 
          {"SPHINCSSHA256192FROBUST", SphincsHashType::SHA256,
           SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHA256192FROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHA256192FROBUST_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHA256192FROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256192FROBUST_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSSHA256192SROBUST", SphincsHashType::SHA256,
           SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHA256192SROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHA256192SROBUST_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHA256192SROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256192SROBUST_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSSHA256192FSIMPLE", SphincsHashType::SHA256,
           SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHA256192FSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHA256192FSIMPLE_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHA256192FSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256192FSIMPLE_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSSHA256192SSIMPLE", SphincsHashType::SHA256,
           SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHA256192SSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHA256192SSIMPLE_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHA256192SSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256192SSIMPLE_CRYPTO_PUBLICKEYBYTES},
 
          {"SPHINCSSHA256256FROBUST", SphincsHashType::SHA256,
           SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHA256256FROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHA256256FROBUST_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHA256256FROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256256FROBUST_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSSHA256256SROBUST", SphincsHashType::SHA256,
           SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHA256256SROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHA256256SROBUST_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHA256256SROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256256SROBUST_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSSHA256256FSIMPLE", SphincsHashType::SHA256,
           SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHA256256FSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHA256256FSIMPLE_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHA256256FSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256256FSIMPLE_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSSHA256256SSIMPLE", SphincsHashType::SHA256,
           SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHA256256SSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHA256256SSIMPLE_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHA256256SSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256256SSIMPLE_CRYPTO_PUBLICKEYBYTES},
 
          {"SPHINCSSHAKE256128FROBUST", SphincsHashType::SHAKE256,
           SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHAKE256128FROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHAKE256128FROBUST_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHAKE256128FROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256128FROBUST_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSSHAKE256128SROBUST", SphincsHashType::SHAKE256,
           SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHAKE256128SROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHAKE256128SROBUST_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHAKE256128SROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256128SROBUST_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSSHAKE256128FSIMPLE", SphincsHashType::SHAKE256,
           SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHAKE256128FSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHAKE256128FSIMPLE_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHAKE256128FSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256128FSIMPLE_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSSHAKE256128SSIMPLE", SphincsHashType::SHAKE256,
           SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHAKE256128SSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHAKE256128SSIMPLE_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHAKE256128SSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256128SSIMPLE_CRYPTO_PUBLICKEYBYTES},
 
          {"SPHINCSSHAKE256192FROBUST", SphincsHashType::SHAKE256,
           SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHAKE256192FROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHAKE256192FROBUST_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHAKE256192FROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256192FROBUST_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSSHAKE256192SROBUST", SphincsHashType::SHAKE256,
           SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHAKE256192SROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHAKE256192SROBUST_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHAKE256192SROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256192SROBUST_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSSHAKE256192FSIMPLE", SphincsHashType::SHAKE256,
           SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHAKE256192FSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHAKE256192FSIMPLE_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHAKE256192FSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256192FSIMPLE_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSSHAKE256192SSIMPLE", SphincsHashType::SHAKE256,
           SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHAKE256192SSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHAKE256192SSIMPLE_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHAKE256192SSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256192SSIMPLE_CRYPTO_PUBLICKEYBYTES},
 
          {"SPHINCSSHAKE256256FROBUST", SphincsHashType::SHAKE256,
           SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHAKE256256FROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHAKE256256FROBUST_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHAKE256256FROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256256FROBUST_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSSHAKE256256SROBUST", SphincsHashType::SHAKE256,
           SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHAKE256256SROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHAKE256256SROBUST_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHAKE256256SROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256256SROBUST_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSSHAKE256256FSIMPLE", SphincsHashType::SHAKE256,
           SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHAKE256256FSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHAKE256256FSIMPLE_AVX2_CRYPTO_PUBLICKEYBYTES},
+          PQCLEAN_SPHINCSSHAKE256256FSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256256FSIMPLE_CRYPTO_PUBLICKEYBYTES},
          {"SPHINCSSHAKE256256SSIMPLE", SphincsHashType::SHAKE256,
           SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHAKE256256SSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHAKE256256SSIMPLE_AVX2_CRYPTO_PUBLICKEYBYTES}}),
+          PQCLEAN_SPHINCSSHAKE256256SSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256256SSIMPLE_CRYPTO_PUBLICKEYBYTES}}),
     [](const testing::TestParamInfo<SphincsUtilsTest::ParamType>& info) {
       return info.param.test_name;
     });
diff --git a/cc/experimental/pqcrypto/signature/subtle/sphincs_verify_test.cc b/cc/experimental/pqcrypto/signature/subtle/sphincs_verify_test.cc
index d19d3e1e9..95f5a0bb4 100644
--- a/cc/experimental/pqcrypto/signature/subtle/sphincs_verify_test.cc
+++ b/cc/experimental/pqcrypto/signature/subtle/sphincs_verify_test.cc
@@ -33,42 +33,42 @@
 #include "tink/util/test_matchers.h"
 
 extern "C" {
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-128f-robust/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-128f-simple/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-128s-robust/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-128s-simple/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-192f-robust/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-192f-simple/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-192s-robust/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-192s-simple/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-256f-robust/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-256f-simple/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-256s-robust/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-haraka-256s-simple/aesni/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-128f-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-128f-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-128s-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-128s-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-192f-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-192f-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-192s-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-192s-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-256f-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-256f-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-256s-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-sha256-256s-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-128f-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-128f-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-128s-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-128s-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-192f-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-192f-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-192s-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-192s-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-256f-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-256f-simple/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-256s-robust/avx2/api.h"
-#include "third_party/pqclean/crypto_sign/sphincs-shake256-256s-simple/avx2/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-128f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-128f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-128s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-128s-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-192f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-192f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-192s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-192s-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-256f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-256f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-256s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-haraka-256s-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-128f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-128f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-128s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-128s-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-192f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-192f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-192s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-192s-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-256f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-256f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-256s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-sha256-256s-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-128f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-128f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-128s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-128s-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-192f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-192f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-192s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-192s-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-256f-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-256f-simple/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-256s-robust/api.h"
+#include "third_party/pqclean/crypto_sign/sphincs-shake256-256s-simple/api.h"
 }
 
 namespace crypto {
@@ -278,156 +278,156 @@ INSTANTIATE_TEST_SUITE_P(
     testing::ValuesIn<SphincsTestCase>(
         {{"SPHINCSHARAKA128FROBUST", SphincsHashType::HARAKA,
           SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSHARAKA128FROBUST_AESNI_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSHARAKA128FROBUST_AESNI_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSHARAKA128FROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA128FROBUST_CRYPTO_BYTES},
          {"SPHINCSHARAKA128SROBUST", SphincsHashType::HARAKA,
           SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSHARAKA128SROBUST_AESNI_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSHARAKA128SROBUST_AESNI_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSHARAKA128SROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA128SROBUST_CRYPTO_BYTES},
          {"SPHINCSHARAKA128FSIMPLE", SphincsHashType::HARAKA,
           SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSHARAKA128FSIMPLE_AESNI_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSHARAKA128FSIMPLE_AESNI_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSHARAKA128FSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA128FSIMPLE_CRYPTO_BYTES},
          {"SPHINCSHARAKA128SSIMPLE", SphincsHashType::HARAKA,
           SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSHARAKA128SSIMPLE_AESNI_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSHARAKA128SSIMPLE_AESNI_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSHARAKA128SSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA128SSIMPLE_CRYPTO_BYTES},
 
          {"SPHINCSHARAKA192FROBUST", SphincsHashType::HARAKA,
           SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSHARAKA192FROBUST_AESNI_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSHARAKA192FROBUST_AESNI_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSHARAKA192FROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA192FROBUST_CRYPTO_BYTES},
          {"SPHINCSHARAKA192SROBUST", SphincsHashType::HARAKA,
           SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSHARAKA192SROBUST_AESNI_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSHARAKA192SROBUST_AESNI_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSHARAKA192SROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA192SROBUST_CRYPTO_BYTES},
          {"SPHINCSHARAKA192FSIMPLE", SphincsHashType::HARAKA,
           SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSHARAKA192FSIMPLE_AESNI_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSHARAKA192FSIMPLE_AESNI_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSHARAKA192FSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA192FSIMPLE_CRYPTO_BYTES},
          {"SPHINCSHARAKA192SSIMPLE", SphincsHashType::HARAKA,
           SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSHARAKA192SSIMPLE_AESNI_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSHARAKA192SSIMPLE_AESNI_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSHARAKA192SSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA192SSIMPLE_CRYPTO_BYTES},
 
          {"SPHINCSHARAKA256FROBUST", SphincsHashType::HARAKA,
           SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSHARAKA256FROBUST_AESNI_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSHARAKA256FROBUST_AESNI_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSHARAKA256FROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA256FROBUST_CRYPTO_BYTES},
          {"SPHINCSHARAKA256SROBUST", SphincsHashType::HARAKA,
           SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSHARAKA256SROBUST_AESNI_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSHARAKA256SROBUST_AESNI_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSHARAKA256SROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA256SROBUST_CRYPTO_BYTES},
          {"SPHINCSHARAKA256FSIMPLE", SphincsHashType::HARAKA,
           SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSHARAKA256FSIMPLE_AESNI_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSHARAKA256FSIMPLE_AESNI_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSHARAKA256FSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA256FSIMPLE_CRYPTO_BYTES},
          {"SPHINCSHARAKA256SSIMPLE", SphincsHashType::HARAKA,
           SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSHARAKA256SSIMPLE_AESNI_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSHARAKA256SSIMPLE_AESNI_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSHARAKA256SSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSHARAKA256SSIMPLE_CRYPTO_BYTES},
 
          {"SPHINCSSHA256128FROBUST", SphincsHashType::SHA256,
           SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHA256128FROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHA256128FROBUST_AVX2_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSSHA256128FROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256128FROBUST_CRYPTO_BYTES},
          {"SPHINCSSHA256128SROBUST", SphincsHashType::SHA256,
           SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHA256128SROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHA256128SROBUST_AVX2_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSSHA256128SROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256128SROBUST_CRYPTO_BYTES},
          {"SPHINCSSHA256128FSIMPLE", SphincsHashType::SHA256,
           SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHA256128FSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHA256128FSIMPLE_AVX2_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSSHA256128FSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256128FSIMPLE_CRYPTO_BYTES},
          {"SPHINCSSHA256128SSIMPLE", SphincsHashType::SHA256,
           SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHA256128SSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHA256128SSIMPLE_AVX2_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSSHA256128SSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256128SSIMPLE_CRYPTO_BYTES},
 
          {"SPHINCSSHA256192FROBUST", SphincsHashType::SHA256,
           SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHA256192FROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHA256192FROBUST_AVX2_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSSHA256192FROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256192FROBUST_CRYPTO_BYTES},
          {"SPHINCSSHA256192SROBUST", SphincsHashType::SHA256,
           SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHA256192SROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHA256192SROBUST_AVX2_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSSHA256192SROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256192SROBUST_CRYPTO_BYTES},
          {"SPHINCSSHA256192FSIMPLE", SphincsHashType::SHA256,
           SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHA256192FSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHA256192FSIMPLE_AVX2_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSSHA256192FSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256192FSIMPLE_CRYPTO_BYTES},
          {"SPHINCSSHA256192SSIMPLE", SphincsHashType::SHA256,
           SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHA256192SSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHA256192SSIMPLE_AVX2_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSSHA256192SSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256192SSIMPLE_CRYPTO_BYTES},
 
          {"SPHINCSSHA256256FROBUST", SphincsHashType::SHA256,
           SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHA256256FROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHA256256FROBUST_AVX2_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSSHA256256FROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256256FROBUST_CRYPTO_BYTES},
          {"SPHINCSSHA256256SROBUST", SphincsHashType::SHA256,
           SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHA256256SROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHA256256SROBUST_AVX2_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSSHA256256SROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256256SROBUST_CRYPTO_BYTES},
          {"SPHINCSSHA256256FSIMPLE", SphincsHashType::SHA256,
           SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHA256256FSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHA256256FSIMPLE_AVX2_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSSHA256256FSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256256FSIMPLE_CRYPTO_BYTES},
          {"SPHINCSSHA256256SSIMPLE", SphincsHashType::SHA256,
           SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHA256256SSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHA256256SSIMPLE_AVX2_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSSHA256256SSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHA256256SSIMPLE_CRYPTO_BYTES},
 
          {"SPHINCSSHAKE256128FROBUST", SphincsHashType::SHAKE256,
           SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHAKE256128FROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHAKE256128FROBUST_AVX2_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSSHAKE256128FROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256128FROBUST_CRYPTO_BYTES},
          {"SPHINCSSHAKE256128SROBUST", SphincsHashType::SHAKE256,
           SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHAKE256128SROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHAKE256128SROBUST_AVX2_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSSHAKE256128SROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256128SROBUST_CRYPTO_BYTES},
          {"SPHINCSSHAKE256128FSIMPLE", SphincsHashType::SHAKE256,
           SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHAKE256128FSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHAKE256128FSIMPLE_AVX2_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSSHAKE256128FSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256128FSIMPLE_CRYPTO_BYTES},
          {"SPHINCSSHAKE256128SSIMPLE", SphincsHashType::SHAKE256,
           SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHAKE256128SSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHAKE256128SSIMPLE_AVX2_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSSHAKE256128SSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256128SSIMPLE_CRYPTO_BYTES},
 
          {"SPHINCSSHAKE256192FROBUST", SphincsHashType::SHAKE256,
           SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHAKE256192FROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHAKE256192FROBUST_AVX2_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSSHAKE256192FROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256192FROBUST_CRYPTO_BYTES},
          {"SPHINCSSHAKE256192SROBUST", SphincsHashType::SHAKE256,
           SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHAKE256192SROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHAKE256192SROBUST_AVX2_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSSHAKE256192SROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256192SROBUST_CRYPTO_BYTES},
          {"SPHINCSSHAKE256192FSIMPLE", SphincsHashType::SHAKE256,
           SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHAKE256192FSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHAKE256192FSIMPLE_AVX2_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSSHAKE256192FSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256192FSIMPLE_CRYPTO_BYTES},
          {"SPHINCSSHAKE256192SSIMPLE", SphincsHashType::SHAKE256,
           SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHAKE256192SSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHAKE256192SSIMPLE_AVX2_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSSHAKE256192SSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256192SSIMPLE_CRYPTO_BYTES},
 
          {"SPHINCSSHAKE256256FROBUST", SphincsHashType::SHAKE256,
           SphincsVariant::ROBUST, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHAKE256256FROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHAKE256256FROBUST_AVX2_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSSHAKE256256FROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256256FROBUST_CRYPTO_BYTES},
          {"SPHINCSSHAKE256256SROBUST", SphincsHashType::SHAKE256,
           SphincsVariant::ROBUST, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHAKE256256SROBUST_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHAKE256256SROBUST_AVX2_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSSHAKE256256SROBUST_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256256SROBUST_CRYPTO_BYTES},
          {"SPHINCSSHAKE256256FSIMPLE", SphincsHashType::SHAKE256,
           SphincsVariant::SIMPLE, SphincsSignatureType::FAST_SIGNING,
-          PQCLEAN_SPHINCSSHAKE256256FSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHAKE256256FSIMPLE_AVX2_CRYPTO_BYTES},
+          PQCLEAN_SPHINCSSHAKE256256FSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256256FSIMPLE_CRYPTO_BYTES},
          {"SPHINCSSHAKE256256SSIMPLE", SphincsHashType::SHAKE256,
           SphincsVariant::SIMPLE, SphincsSignatureType::SMALL_SIGNATURE,
-          PQCLEAN_SPHINCSSHAKE256256SSIMPLE_AVX2_CRYPTO_SECRETKEYBYTES,
-          PQCLEAN_SPHINCSSHAKE256256SSIMPLE_AVX2_CRYPTO_BYTES}}),
+          PQCLEAN_SPHINCSSHAKE256256SSIMPLE_CRYPTO_SECRETKEYBYTES,
+          PQCLEAN_SPHINCSSHAKE256256SSIMPLE_CRYPTO_BYTES}}),
     [](const testing::TestParamInfo<SphincsVerifyTest::ParamType>& info) {
       return info.param.test_name;
     });
author	Tink Team <tink-dev@google.com>	2022-06-13 09:34:54 -0700
committer	Copybara-Service <copybara-worker@google.com>	2022-06-13 09:35:49 -0700
commit	9db9e8a26801c90fb2d3d4799f978914242b596c (patch)
tree	3a55cf234eb9bce15a95d4f522e3f1b2a7ba47cd /cc/experimental
parent	5d81c95caec543d2fc00cb68bd1a971031ffea5b (diff)
download	tink-9db9e8a26801c90fb2d3d4799f978914242b596c.tar.gz