diff --git a/.gitignore b/.gitignore
index 5f2ba3e..d6e2211 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,4 @@
+deps/is_utf8/.github/
 node_modules/
 prebuilds/
 build/
diff --git a/LICENSE b/LICENSE
index 0b37d7b..2e1dc33 100644
--- a/LICENSE
+++ b/LICENSE
@@ -23,10 +23,29 @@ IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 """
 
-This license applies to parts originating from
-https://www.cl.cam.ac.uk/~mgk25/ucs/utf8_check.c:
+This license applies to all parts of utf-8-validate that are not externally
+maintained libraries.
+
+The externally maintained is_utf8 library used by utf-8-validate, located at
+deps/is_utf8, is licensed as follows:
 
 """
-Markus Kuhn <http://www.cl.cam.ac.uk/~mgk25/> -- 2005-03-30
-License: http://www.cl.cam.ac.uk/~mgk25/short-license.html
+Copyright 2022 The is_utf8 authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 """
diff --git a/binding.gyp b/binding.gyp
index 30edf27..d873b5f 100644
--- a/binding.gyp
+++ b/binding.gyp
@@ -2,8 +2,11 @@
   'targets': [
     {
       'target_name': 'validation',
-      'sources': ['src/validation.c'],
-      'cflags': ['-std=c99'],
+      'sources': [
+        'src/validation.cc',
+        'deps/is_utf8/src/is_utf8.cpp'
+      ],
+      'cflags_cc': ['-std=gnu++11'],
       'conditions': [
         ["OS=='mac'", {
           'xcode_settings': {
diff --git a/deps/is_utf8/CMakeLists.txt b/deps/is_utf8/CMakeLists.txt
new file mode 100644
index 0000000..39b8411
--- /dev/null
+++ b/deps/is_utf8/CMakeLists.txt
@@ -0,0 +1,106 @@
+cmake_minimum_required(VERSION 3.15)
+
+project(is_utf8
+  DESCRIPTION "Fast UTF-8 Validation"
+  LANGUAGES CXX
+  VERSION 1.2.1
+)
+
+include(GNUInstallDirs)
+include(CTest)
+
+option(IS_UTF8_SANITIZE "Sanitize addresses" OFF)
+
+if (NOT CMAKE_BUILD_TYPE)
+  message(STATUS "No build type selected, default to Release")
+  if(IS_UTF8_SANITIZE)
+    set(CMAKE_BUILD_TYPE Debug CACHE STRING "Choose the type of build." FORCE)
+  else()
+    set(CMAKE_BUILD_TYPE Release CACHE STRING "Choose the type of build." FORCE)
+  endif()
+endif()
+
+set(CMAKE_CXX_STANDARD 14)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+set(CMAKE_MACOSX_RPATH OFF)
+
+set(IS_UTF8_LIB_VERSION "1.2.1" CACHE STRING "is_utf8 library version")
+set(IS_UTF8_LIB_SOVERSION "1" CACHE STRING "is_utf8 library soversion")
+
+set(IS_UTF8_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/src)
+add_subdirectory(src)
+
+if (BUILD_TESTING)
+  message(STATUS "The tests are enabled.")
+  add_subdirectory(tests)
+else()
+  message(STATUS "The tests are disabled.")
+endif(BUILD_TESTING)
+
+
+add_subdirectory(benchmarks)
+# ---- Install rules ----
+add_library(is_utf8::is_utf8 ALIAS is_utf8)
+
+set_target_properties(
+    is_utf8 PROPERTIES
+    VERSION "${IS_UTF8_LIB_VERSION}"
+    SOVERSION "${IS_UTF8_LIB_SOVERSION}"
+    WINDOWS_EXPORT_ALL_SYMBOLS YES
+)
+
+include(CMakePackageConfigHelpers)
+include(GNUInstallDirs)
+
+install(
+    FILES include/is_utf8.h
+    DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
+    COMPONENT is_utf8_Development
+)
+
+install(
+    TARGETS is_utf8
+    EXPORT is_utf8Targets
+    RUNTIME COMPONENT is_utf8_Runtime
+    LIBRARY COMPONENT is_utf8_Runtime
+    NAMELINK_COMPONENT is_utf8_Development
+    ARCHIVE COMPONENT is_utf8_Development
+    INCLUDES DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
+)
+
+configure_file(cmake/is_utf8-config.cmake.in is_utf8-config.cmake @ONLY)
+
+write_basic_package_version_file(
+    is_utf8-config-version.cmake
+    COMPATIBILITY SameMinorVersion
+)
+
+set(
+    IS_UTF8_INSTALL_CMAKEDIR "${CMAKE_INSTALL_LIBDIR}/cmake/is_utf8"
+    CACHE STRING "CMake package config location relative to the install prefix"
+)
+mark_as_advanced(IS_UTF8_INSTALL_CMAKEDIR)
+
+install(
+    FILES
+    "${PROJECT_BINARY_DIR}/is_utf8-config.cmake"
+    "${PROJECT_BINARY_DIR}/is_utf8-config-version.cmake"
+    DESTINATION "${IS_UTF8_INSTALL_CMAKEDIR}"
+    COMPONENT is_utf8_Development
+)
+
+#
+# CPack
+#
+if(is_top_project)
+  set(CPACK_PACKAGE_VENDOR "Daniel Lemire")
+  set(CPACK_PACKAGE_CONTACT "lemire@gmail.com")
+  set(CPACK_RESOURCE_FILE_LICENSE "${PROJECT_SOURCE_DIR}/LICENSE-MIT")
+  set(CPACK_RPM_PACKAGE_LICENSE "${PROJECT_SOURCE_DIR}/LICENSE-MIT")
+  set(CPACK_RESOURCE_FILE_README "${PROJECT_SOURCE_DIR}/README.md")
+  set(CPACK_SOURCE_GENERATOR "TGZ;ZIP")
+  include(CPack)
+endif()
+
+# ----
diff --git a/deps/is_utf8/LICENSE-APACHE b/deps/is_utf8/LICENSE-APACHE
new file mode 100644
index 0000000..db01662
--- /dev/null
+++ b/deps/is_utf8/LICENSE-APACHE
@@ -0,0 +1,204 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+NOTE: This software may be used as part of software released under the
+GNU General Public License (GPL) version 2.
diff --git a/deps/is_utf8/LICENSE-BOOST b/deps/is_utf8/LICENSE-BOOST
new file mode 100644
index 0000000..36b7cd9
--- /dev/null
+++ b/deps/is_utf8/LICENSE-BOOST
@@ -0,0 +1,23 @@
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/deps/is_utf8/LICENSE-MIT b/deps/is_utf8/LICENSE-MIT
new file mode 100644
index 0000000..5efe84c
--- /dev/null
+++ b/deps/is_utf8/LICENSE-MIT
@@ -0,0 +1,18 @@
+Copyright 2022 The is_utf8 authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/deps/is_utf8/README.md b/deps/is_utf8/README.md
new file mode 100644
index 0000000..acc6895
--- /dev/null
+++ b/deps/is_utf8/README.md
@@ -0,0 +1,59 @@
+# is_utf8
+
+Most strings online are in unicode using the UTF-8 encoding. Validating strings
+quickly before accepting them is important.
+
+
+
+
+## How to use is_utf8
+
+This is a simple one-source file library to validate UTF-8 strings at high speeds using SIMD instructions. It works on all platforms (ARM, x64).
+
+Build and link `is_utf8.cpp` with your project. Code usage:
+
+```C++
+  #include "is_utf8.h"
+
+  char * mystring = ...
+  bool is_it_valid = is_utf8(mystring, thestringlength);
+```
+
+It should be able to validate strings using less than 1 cycle per input byte.
+
+## Reference
+
+- John Keiser, Daniel Lemire, [Validating UTF-8 In Less Than One Instruction Per Byte](https://arxiv.org/abs/2010.03090), Software: Practice & Experience 51 (5), 2021
+
+### Want more?
+
+If you want a wide range of fast Unicode function for production use, you can rely on the simdutf library. It is as simple as the following:
+
+```C++
+#include "simdutf.cpp"
+#include "simdutf.h"
+
+int main(int argc, char *argv[]) {
+  const char *source = "1234";
+  // 4 == strlen(source)
+  bool validutf8 = simdutf::validate_utf8(source, 4);
+  if (validutf8) {
+    std::cout << "valid UTF-8" << std::endl;
+  } else {
+    std::cerr << "invalid UTF-8" << std::endl;
+    return EXIT_FAILURE;
+  }
+}
+```
+
+See https://github.com/simdutf/
+
+
+## License
+
+This library is distributed under the terms of any of the following
+licenses, at your option:
+
+* Apache License (Version 2.0) [LICENSE-APACHE](LICENSE-APACHE),
+* Boost Software License [LICENSE-BOOST](LICENSE-BOOST), or
+* MIT License [LICENSE-MIT](LICENSE-MIT).
diff --git a/deps/is_utf8/benchmarks/CMakeLists.txt b/deps/is_utf8/benchmarks/CMakeLists.txt
new file mode 100644
index 0000000..0bceec7
--- /dev/null
+++ b/deps/is_utf8/benchmarks/CMakeLists.txt
@@ -0,0 +1,13 @@
+
+include(${PROJECT_SOURCE_DIR}/cmake/import.cmake)
+set_off(SIMDUTF_TOOLS)
+set_off(SIMDUTF_BENCHMARKS)
+
+import_dependency(simdutf simdutf/simdutf v2.0.9)
+set(BUILD_TESTING OFF)
+add_dependency(simdutf)
+unset(BUILD_TESTING)
+
+add_executable(bench bench.cpp)
+target_link_libraries(bench PRIVATE is_utf8)
+target_link_libraries(bench PRIVATE simdutf)
diff --git a/deps/is_utf8/benchmarks/bench.cpp b/deps/is_utf8/benchmarks/bench.cpp
new file mode 100644
index 0000000..4492894
--- /dev/null
+++ b/deps/is_utf8/benchmarks/bench.cpp
@@ -0,0 +1,251 @@
+#include "is_utf8.h"
+#include "simdutf.h"
+#include <assert.h>
+#include <chrono>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+uint64_t nano() {
+  return std::chrono::duration_cast<::std::chrono::nanoseconds>(
+             std::chrono::steady_clock::now().time_since_epoch())
+      .count();
+}
+
+#ifdef _MSC_VER
+#define never_inline __declspec(noinline)
+#else
+#define never_inline __attribute__((noinline))
+#endif
+
+// generate a string having at least length N
+// can exceed by up to 3 chars, returns the actual length
+size_t populate_utf8(char *data, size_t N) {
+  size_t i = 0;
+  for (; i < N;) {
+    int w = rand() & 0xFF;
+    if (w < 0x80) {
+      data[i++] = 0x20; // w;
+    } else if (w < 0xE0) {
+      data[i++] = 0xC2 + rand() % (0xDF - 0xC2 + 1);
+      data[i++] = 0x80 + rand() % (0xBF - 0x80 + 1);
+    } else if (w == 0xE0) {
+      data[i++] = w;
+      data[i++] = 0xA0 + rand() % (0xBF - 0xA0 + 1);
+      data[i++] = 0x80 + rand() % (0xBF - 0x80 + 1);
+    } else if (w <= 0xEC) {
+      data[i++] = w;
+      data[i++] = 0x80 + rand() % (0xBF - 0x80 + 1);
+      data[i++] = 0x80 + rand() % (0xBF - 0x80 + 1);
+    } else if (w == 0xED) {
+      data[i++] = w;
+      data[i++] = 0x80 + rand() % (0x9F - 0x80 + 1);
+      data[i++] = 0x80 + rand() % (0xBF - 0x80 + 1);
+    } else if (w <= 0xEF) {
+      data[i++] = w;
+      data[i++] = 0x80 + rand() % (0xBF - 0x80 + 1);
+      data[i++] = 0x80 + rand() % (0xBF - 0x80 + 1);
+    } else if (w < 0xF0) {
+      data[i++] = 0xF1 + rand() % (0xF3 - 0xF1 + 1);
+      data[i++] = 0x80 + rand() % (0xBF - 0x80 + 1);
+      data[i++] = 0x80 + rand() % (0xBF - 0x80 + 1);
+      data[i++] = 0x80 + rand() % (0xBF - 0x80 + 1);
+    } else if (w == 0xF0) {
+      data[i++] = w;
+      data[i++] = 0x90 + rand() % (0xBF - 0x90 + 1);
+      data[i++] = 0x80 + rand() % (0xBF - 0x80 + 1);
+      data[i++] = 0x80 + rand() % (0xBF - 0x80 + 1);
+    } else if (w <= 0xF3) {
+      data[i++] = 0xF1 + rand() % (0xF3 - 0xF1 + 1);
+      data[i++] = 0x80 + rand() % (0xBF - 0x80 + 1);
+      data[i++] = 0x80 + rand() % (0xBF - 0x80 + 1);
+      data[i++] = 0x80 + rand() % (0xBF - 0x80 + 1);
+    } else if (w == 0xF4) {
+      data[i++] = w;
+      data[i++] = 0x80 + rand() % (0x8F - 0x80 + 1);
+      data[i++] = 0x80 + rand() % (0xBF - 0x80 + 1);
+      data[i++] = 0x80 + rand() % (0xBF - 0x80 + 1);
+    }
+  }
+  data[i] = '\0';
+  return i;
+}
+
+// copied in part from Guava
+static never_inline bool basic_validate_utf8(const char *b, size_t length) {
+  const unsigned char *bytes = (const unsigned char *)b;
+  for (size_t index = 0;;) {
+    unsigned char byte1;
+
+    do { // fast ASCII Path
+      if (index >= length) {
+        return true;
+      }
+      byte1 = bytes[index++];
+    } while (byte1 < 0x80);
+    if (byte1 < 0xE0) {
+      // Two-byte form.
+      if (index == length) {
+        return false;
+      }
+      if (byte1 < 0xC2 || bytes[index++] > 0xBF) {
+        return false;
+      }
+    } else if (byte1 < 0xF0) {
+      // Three-byte form.
+      if (index + 1 >= length) {
+        return false;
+      }
+      unsigned char byte2 = bytes[index++];
+      if (byte2 > 0xBF
+          // Overlong? 5 most significant bits must not all be zero.
+          || (byte1 == 0xE0 && byte2 < 0xA0)
+          // Check for illegal surrogate codepoints.
+          || (byte1 == 0xED && 0xA0 <= byte2)
+          // Third byte trailing-byte test.
+          || bytes[index++] > 0xBF) {
+        return false;
+      }
+    } else {
+
+      // Four-byte form.
+      if (index + 2 >= length) {
+        return false;
+      }
+      int byte2 = bytes[index++];
+      if (byte2 > 0xBF
+          // Check that 1 <= plane <= 16. Tricky optimized form of:
+          // if (byte1 > (byte) 0xF4
+          //     || byte1 == (byte) 0xF0 && byte2 < (byte) 0x90
+          //     || byte1 == (byte) 0xF4 && byte2 > (byte) 0x8F)
+          || (((byte1 << 28) + (byte2 - 0x90)) >> 30) != 0
+          // Third byte trailing-byte test
+          || bytes[index++] > 0xBF
+          // Fourth byte trailing-byte test
+          || bytes[index++] > 0xBF) {
+        return false;
+      }
+    }
+  }
+}
+
+
+bool zerobuffer_bench(size_t N) {
+  printf("zero buffer \n");
+  printf("string size = %zu \n", N);
+  char *input = new char[N]{};
+  volatile bool isgood{true};
+
+  {
+    uint64_t start = nano();
+    uint64_t finish = start;
+    size_t count{0};
+    uint64_t threshold = 500000000;
+    for (; finish - start < threshold;) {
+      count++;
+      isgood &= basic_validate_utf8(input, N);
+      finish = nano();
+    }
+    double t = (N * count) / double(finish - start);
+
+    printf("basic_validate_utf8   %f GB/s\n", t);
+  }
+
+  {
+    uint64_t start = nano();
+    uint64_t finish = start;
+    size_t count{0};
+    uint64_t threshold = 500000000;
+    for (; finish - start < threshold;) {
+      count++;
+      isgood &= simdutf::validate_utf8(input, N);
+      finish = nano();
+    }
+    double t = (N * count) / double(finish - start);
+
+    printf("simdutf               %f GB/s\n", t);
+  }
+
+  {
+    uint64_t start = nano();
+    uint64_t finish = start;
+    size_t count{0};
+    uint64_t threshold = 500000000;
+    for (; finish - start < threshold;) {
+      count++;
+      isgood &= is_utf8(input, N);
+      finish = nano();
+    }
+    double t = (N * count) / double(finish - start);
+
+    printf("is_utf8               %f GB/s\n", t);
+  }
+  delete[] input;
+  printf("\n");
+  return isgood;
+}
+
+bool bench(size_t N) {
+  printf("random UTF-8\n");
+  printf("string size = %zu \n", N);
+  char *input = new char[N];
+  populate_utf8(input, N);
+  volatile bool isgood{true};
+
+  {
+    uint64_t start = nano();
+    uint64_t finish = start;
+    size_t count{0};
+    uint64_t threshold = 500000000;
+    for (; finish - start < threshold;) {
+      count++;
+      isgood &= basic_validate_utf8(input, N);
+      finish = nano();
+    }
+    double t = (N * count) / double(finish - start);
+
+    printf("basic_validate_utf8   %f GB/s\n", t);
+  }
+
+  {
+    uint64_t start = nano();
+    uint64_t finish = start;
+    size_t count{0};
+    uint64_t threshold = 500000000;
+    for (; finish - start < threshold;) {
+      count++;
+      isgood &= simdutf::validate_utf8(input, N);
+      finish = nano();
+    }
+    double t = (N * count) / double(finish - start);
+
+    printf("simdutf               %f GB/s\n", t);
+  }
+
+  {
+    uint64_t start = nano();
+    uint64_t finish = start;
+    size_t count{0};
+    uint64_t threshold = 500000000;
+    for (; finish - start < threshold;) {
+      count++;
+      isgood &= is_utf8(input, N);
+      finish = nano();
+    }
+    double t = (N * count) / double(finish - start);
+
+    printf("is_utf8               %f GB/s\n", t);
+  }
+  delete[] input;
+  printf("\n");
+  return isgood;
+}
+
+int main() {
+  return (bench(40096) & bench(100000) & bench(50000))
+  & (zerobuffer_bench(40096) & zerobuffer_bench(100000) & zerobuffer_bench(50000))
+  ? EXIT_SUCCESS : EXIT_FAILURE;
+}
\ No newline at end of file
diff --git a/deps/is_utf8/cmake/add_cpp_test.cmake b/deps/is_utf8/cmake/add_cpp_test.cmake
new file mode 100644
index 0000000..c4ce6a5
--- /dev/null
+++ b/deps/is_utf8/cmake/add_cpp_test.cmake
@@ -0,0 +1,59 @@
+# Helper so we don't have to repeat ourselves so much
+# Usage: add_cpp_test(testname [COMPILE_ONLY] [SOURCES a.cpp b.cpp ...] [LABELS acceptance per_implementation ...])
+# SOURCES defaults to testname.cpp if not specified.
+function(add_cpp_test TEST_NAME)
+  # Parse arguments
+  cmake_parse_arguments(PARSE_ARGV 1 ARGS "COMPILE_ONLY;LIBRARY;WILL_FAIL" "" "SOURCES;LABELS;DEPENDENCY_OF")
+  if (NOT ARGS_SOURCES)
+    list(APPEND ARGS_SOURCES ${TEST_NAME}.cpp)
+  endif()
+  if (ARGS_COMPILE_ONLY)
+    list(APPEND ${ARGS_LABELS} compile_only)
+  endif()
+  if (IS_UTF8_SANITIZE)
+    add_compile_options(-fsanitize=address  -fno-omit-frame-pointer -fno-sanitize-recover=all)
+    add_compile_definitions(ASAN_OPTIONS=detect_leaks=1)
+  endif()
+  # Add the compile target
+  if (ARGS_LIBRARY)
+    add_library(${TEST_NAME} STATIC ${ARGS_SOURCES})
+  else(ARGS_LIBRARY)
+    add_executable(${TEST_NAME} ${ARGS_SOURCES})
+  endif(ARGS_LIBRARY)
+
+  # Add test
+  if (ARGS_COMPILE_ONLY OR ARGS_LIBRARY)
+    add_test(
+      NAME ${TEST_NAME}
+      COMMAND ${CMAKE_COMMAND} --build . --target ${TEST_NAME} --config $<CONFIGURATION>
+      WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
+    )
+    set_target_properties(${TEST_NAME} PROPERTIES EXCLUDE_FROM_ALL TRUE EXCLUDE_FROM_DEFAULT_BUILD TRUE)
+  else()
+    add_test(${TEST_NAME} ${TEST_NAME})
+
+    # Add to <label>_tests make targets
+    foreach(label ${ARGS_LABELS})
+      list(APPEND ARGS_DEPENDENCY_OF ${label})
+    endforeach(label ${ARGS_LABELS})
+  endif()
+
+  # Add to test labels
+  if (ARGS_LABELS)
+    set_property(TEST ${TEST_NAME} APPEND PROPERTY LABELS ${ARGS_LABELS})
+  endif()
+
+  # Add as a dependency of given targets
+  foreach(dependency_of ${ARGS_DEPENDENCY_OF})
+    if (NOT TARGET ${dependency_of}_tests)
+      add_custom_target(${dependency_of}_tests)
+      add_dependencies(all_tests ${dependency_of}_tests)
+    endif(NOT TARGET ${dependency_of}_tests)
+    add_dependencies(${dependency_of}_tests ${TEST_NAME})
+  endforeach(dependency_of ${ARGS_DEPENDENCY_OF})
+
+  # If it will fail, mark the test as such
+  if (ARGS_WILL_FAIL)
+    set_property(TEST ${TEST_NAME} PROPERTY WILL_FAIL TRUE)
+  endif()
+endfunction()
diff --git a/deps/is_utf8/cmake/import.cmake b/deps/is_utf8/cmake/import.cmake
new file mode 100644
index 0000000..d67e7f3
--- /dev/null
+++ b/deps/is_utf8/cmake/import.cmake
@@ -0,0 +1,48 @@
+set(dep_root "${IS_UTF8_SOURCE_DIR}/dependencies/.cache")
+if(DEFINED ENV{IS_UTF8_DEPENDENCY_CACHE_DIR})
+  set(dep_root "$ENV{IS_UTF8_DEPENDENCY_CACHE_DIR}")
+endif()
+
+function(import_dependency NAME GITHUB_REPO COMMIT)
+  message(STATUS "Importing ${NAME} (${GITHUB_REPO}@${COMMIT})")
+  set(target "${dep_root}/${NAME}")
+
+  # If the folder exists in the cache, then we assume that everything is as
+  # should be and do nothing
+  if(EXISTS "${target}")
+    set("${NAME}_SOURCE_DIR" "${target}" PARENT_SCOPE)
+    return()
+  endif()
+
+  set(zip_url "https://github.com/${GITHUB_REPO}/archive/${COMMIT}.zip")
+  set(archive "${dep_root}/archive.zip")
+  set(dest "${dep_root}/_extract")
+
+  file(DOWNLOAD "${zip_url}" "${archive}")
+  file(MAKE_DIRECTORY "${dest}")
+  execute_process(
+          WORKING_DIRECTORY "${dest}"
+          COMMAND "${CMAKE_COMMAND}" -E tar xf "${archive}")
+  file(REMOVE "${archive}")
+
+  # GitHub archives only ever have one folder component at the root, so this
+  # will always match that single folder
+  file(GLOB dir LIST_DIRECTORIES YES "${dest}/*")
+
+  file(RENAME "${dir}" "${target}")
+
+  set("${NAME}_SOURCE_DIR" "${target}" PARENT_SCOPE)
+endfunction()
+
+# Delegates to the dependency
+macro(add_dependency NAME)
+  if(NOT DEFINED "${NAME}_SOURCE_DIR")
+    message(FATAL_ERROR "Missing ${NAME}_SOURCE_DIR variable")
+  endif()
+
+  add_subdirectory("${${NAME}_SOURCE_DIR}" "${PROJECT_BINARY_DIR}/_deps/${NAME}")
+endmacro()
+
+function(set_off NAME)
+  set("${NAME}" OFF CACHE INTERNAL "")
+endfunction()
diff --git a/deps/is_utf8/cmake/is_utf8-config.cmake.in b/deps/is_utf8/cmake/is_utf8-config.cmake.in
new file mode 100644
index 0000000..fb4ad11
--- /dev/null
+++ b/deps/is_utf8/cmake/is_utf8-config.cmake.in
@@ -0,0 +1,2 @@
+
+include("${CMAKE_CURRENT_LIST_DIR}/is_utf8Targets.cmake")
diff --git a/deps/is_utf8/include/is_utf8.h b/deps/is_utf8/include/is_utf8.h
new file mode 100644
index 0000000..66e8a8f
--- /dev/null
+++ b/deps/is_utf8/include/is_utf8.h
@@ -0,0 +1,10 @@
+#ifndef IS_UTF8
+#include <stddef.h>
+
+// Check whether the provided string is UTF-8.
+// The function is designed for use cases where
+// 99.99% of the inputs are valid UTF-8.
+// Thus the function unconditionally scans the
+// whole input.
+bool is_utf8(const char *src, size_t len);
+#endif // IS_UTF8
\ No newline at end of file
diff --git a/deps/is_utf8/src/CMakeLists.txt b/deps/is_utf8/src/CMakeLists.txt
new file mode 100644
index 0000000..b688831
--- /dev/null
+++ b/deps/is_utf8/src/CMakeLists.txt
@@ -0,0 +1,38 @@
+add_library(is_utf8-include-source INTERFACE)
+target_include_directories(is_utf8-include-source INTERFACE $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>)
+add_library(is_utf8-source INTERFACE)
+target_sources(is_utf8-source INTERFACE $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>/is_utf8.cpp)
+target_link_libraries(is_utf8-source INTERFACE is_utf8-include-source)
+add_library(is_utf8 STATIC is_utf8.cpp)
+target_include_directories(is_utf8 PRIVATE $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}> )
+target_include_directories(is_utf8 PUBLIC "$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>")
+
+if(IS_UTF8_SANITIZE)
+  target_compile_options(is_utf8 INTERFACE -fsanitize=address  -fno-omit-frame-pointer -fno-sanitize-recover=all)
+  target_compile_definitions(is_utf8 INTERFACE ASAN_OPTIONS=detect_leaks=1)
+  target_link_libraries(is_utf8 INTERFACE -fsanitize=address  -fno-omit-frame-pointer -fno-sanitize-recover=all)
+endif()
+
+if(MSVC)
+  if("${MSVC_TOOLSET_VERSION}" STREQUAL "140")
+    target_compile_options(is_utf8 INTERFACE /W0 /sdl)
+    set(is_utf8_LEGACY_VISUAL_STUDIO TRUE)
+  else()
+    target_compile_options(is_utf8 INTERFACE /WX /W3 /sdl /w34714) # https://docs.microsoft.com/en-us/cpp/error-messages/compiler-warnings/compiler-warning-level-4-c4714?view=vs-2019
+  endif()
+else(MSVC)
+  if(NOT WIN32)
+    target_compile_options(is_utf8 INTERFACE -fPIC)
+  endif()
+  target_compile_options(is_utf8 PRIVATE -Wall -Wextra -Weffc++)
+  target_compile_options(is_utf8 PRIVATE -Wfatal-errors -Wsign-compare -Wshadow -Wwrite-strings -Wpointer-arith -Winit-self -Wconversion -Wno-sign-conversion)
+endif(MSVC)
+
+# workaround for GNU GCC poor AVX load/store code generation
+if ((CMAKE_CXX_COMPILER_ID STREQUAL "GNU") AND (CMAKE_SYSTEM_PROCESSOR MATCHES "^(i.86|x86(_64)?)$"))
+  target_compile_options(is_utf8 PRIVATE -mno-avx256-split-unaligned-load -mno-avx256-split-unaligned-store)
+endif()
+
+if(MSVC AND BUILD_SHARED_LIBS)
+  set(is_utf8_WINDOWS_DLL TRUE)
+endif()
\ No newline at end of file
diff --git a/deps/is_utf8/src/is_utf8.cpp b/deps/is_utf8/src/is_utf8.cpp
new file mode 100644
index 0000000..bfd7612
--- /dev/null
+++ b/deps/is_utf8/src/is_utf8.cpp
@@ -0,0 +1,6740 @@
+#ifndef IS_UTF8_H
+#define IS_UTF8_H
+#include <cstring>
+
+#ifndef IS_UTF8_COMPILER_CHECK_H
+#define IS_UTF8_COMPILER_CHECK_H
+
+#ifndef __cplusplus
+#error we require a C++ compiler
+#endif
+
+#ifndef IS_UTF8_CPLUSPLUS
+#if defined(_MSVC_LANG) && !defined(__clang__)
+#define IS_UTF8_CPLUSPLUS (_MSC_VER == 1900 ? 201103L : _MSVC_LANG)
+#else
+#define IS_UTF8_CPLUSPLUS __cplusplus
+#endif
+#endif
+
+// C++ 17
+#if !defined(IS_UTF8_CPLUSPLUS17) && (IS_UTF8_CPLUSPLUS >= 201703L)
+#define IS_UTF8_CPLUSPLUS17 1
+#endif
+
+// C++ 14
+#if !defined(IS_UTF8_CPLUSPLUS14) && (IS_UTF8_CPLUSPLUS >= 201402L)
+#define IS_UTF8_CPLUSPLUS14 1
+#endif
+
+// C++ 11
+#if !defined(IS_UTF8_CPLUSPLUS11) && (IS_UTF8_CPLUSPLUS >= 201103L)
+#define IS_UTF8_CPLUSPLUS11 1
+#endif
+
+#ifndef IS_UTF8_CPLUSPLUS11
+#error we require a compiler compliant with the C++11 standard
+#endif
+
+#endif // IS_UTF8_COMPILER_CHECK_H
+
+#ifndef IS_UTF8_COMMON_DEFS_H
+#define IS_UTF8_COMMON_DEFS_H
+
+#include <cassert>
+
+#ifndef IS_UTF8_PORTABILITY_H
+#define IS_UTF8_PORTABILITY_H
+
+#include <cassert>
+#include <cfloat>
+#include <cstddef>
+#include <cstdint>
+#include <cstdlib>
+#ifndef _WIN32
+// strcasecmp, strncasecmp
+#include <strings.h>
+#endif
+
+#ifdef _MSC_VER
+#define IS_UTF8_VISUAL_STUDIO 1
+/**
+ * We want to differentiate carefully between
+ * clang under visual studio and regular visual
+ * studio.
+ *
+ * Under clang for Windows, we enable:
+ *  * target pragmas so that part and only part of the
+ *     code gets compiled for advanced instructions.
+ *
+ */
+#ifdef __clang__
+// clang under visual studio
+#define IS_UTF8_CLANG_VISUAL_STUDIO 1
+#else
+// just regular visual studio (best guess)
+#define IS_UTF8_REGULAR_VISUAL_STUDIO 1
+#endif // __clang__
+#endif // _MSC_VER
+
+#ifdef IS_UTF8_REGULAR_VISUAL_STUDIO
+// https://en.wikipedia.org/wiki/C_alternative_tokens
+// This header should have no effect, except maybe
+// under Visual Studio.
+#include <iso646.h>
+#endif
+
+#if defined(__x86_64__) || defined(_M_AMD64)
+#define IS_UTF8_IS_X86_64 1
+#elif defined(__aarch64__) || defined(_M_ARM64)
+#define IS_UTF8_IS_ARM64 1
+#elif defined(__PPC64__) || defined(_M_PPC64)
+//#define IS_UTF8_IS_PPC64 1
+#pragma message("The  library does yet support SIMD acceleration under\
+POWER processors.")
+#else
+#define IS_UTF8_IS_32BITS 1
+
+// We do not support 32-bit platforms, but it can be
+// handy to identify them.
+#if defined(_M_IX86) || defined(__i386__)
+#define IS_UTF8_IS_X86_32BITS 1
+#elif defined(__arm__) || defined(_M_ARM)
+#define IS_UTF8_IS_ARM_32BITS 1
+#elif defined(__PPC__) || defined(_M_PPC)
+#define IS_UTF8_IS_PPC_32BITS 1
+#endif
+
+#endif // defined(__x86_64__) || defined(_M_AMD64)
+
+// this is almost standard?
+#define IS_UTF8_STRINGIFY_IMPLEMENTATION_(a) #a
+#define IS_UTF8_STRINGIFY(a) IS_UTF8_STRINGIFY_IMPLEMENTATION_(a)
+
+// We are going to use runtime dispatch.
+#ifdef IS_UTF8_IS_X86_64
+#ifdef __clang__
+// clang does not have GCC push pop
+// warning: clang attribute push can't be used within a namespace in clang up
+// til 8.0 so IS_UTF8_TARGET_REGION and IS_UTF8_UNTARGET_REGION must be
+// *outside* of a namespace.
+#define IS_UTF8_TARGET_REGION(T)                                               \
+  _Pragma(IS_UTF8_STRINGIFY(                                                   \
+      clang attribute push(__attribute__((target(T))), apply_to = function)))
+#define IS_UTF8_UNTARGET_REGION _Pragma("clang attribute pop")
+#elif defined(__GNUC__)
+// GCC is easier
+#define IS_UTF8_TARGET_REGION(T)                                               \
+  _Pragma("GCC push_options") _Pragma(IS_UTF8_STRINGIFY(GCC target(T)))
+#define IS_UTF8_UNTARGET_REGION _Pragma("GCC pop_options")
+#endif // clang then gcc
+
+#endif // x86
+
+// Default target region macros don't do anything.
+#ifndef IS_UTF8_TARGET_REGION
+#define IS_UTF8_TARGET_REGION(T)
+#define IS_UTF8_UNTARGET_REGION
+#endif
+
+#if defined(__GNUC__) && !defined(__clang__)
+#if __GNUC__ >= 11
+#define IS_UTF8_GCC11ORMORE 1
+#endif //  __GNUC__ >= 11
+#endif // defined(__GNUC__) && !defined(__clang__)
+
+#endif // IS_UTF8_PORTABILITY_H
+#ifndef IS_UTF8_AVX512_H_
+#define IS_UTF8_AVX512_H_
+
+/*
+    It's possible to override AVX512 settings with cmake DCMAKE_CXX_FLAGS.
+
+    All preprocessor directives has form `IS_UTF8_HAS_AVX512{feature}`,
+    where a feature is a code name for extensions.
+
+    Please see the listing below to find which are supported.
+*/
+
+#ifndef IS_UTF8_HAS_AVX512F
+#if defined(__AVX512F__) && __AVX512F__ == 1
+#define IS_UTF8_HAS_AVX512F 1
+#endif
+#endif
+
+#ifndef IS_UTF8_HAS_AVX512DQ
+#if defined(__AVX512DQ__) && __AVX512DQ__ == 1
+#define IS_UTF8_HAS_AVX512DQ 1
+#endif
+#endif
+
+#ifndef IS_UTF8_HAS_AVX512IFMA
+#if defined(__AVX512IFMA__) && __AVX512IFMA__ == 1
+#define IS_UTF8_HAS_AVX512IFMA 1
+#endif
+#endif
+
+#ifndef IS_UTF8_HAS_AVX512CD
+#if defined(__AVX512CD__) && __AVX512CD__ == 1
+#define IS_UTF8_HAS_AVX512CD 1
+#endif
+#endif
+
+#ifndef IS_UTF8_HAS_AVX512BW
+#if defined(__AVX512BW__) && __AVX512BW__ == 1
+#define IS_UTF8_HAS_AVX512BW 1
+#endif
+#endif
+
+#ifndef IS_UTF8_HAS_AVX512VL
+#if defined(__AVX512VL__) && __AVX512VL__ == 1
+#define IS_UTF8_HAS_AVX512VL 1
+#endif
+#endif
+
+#ifndef IS_UTF8_HAS_AVX512VBMI
+#if defined(__AVX512VBMI__) && __AVX512VBMI__ == 1
+#define IS_UTF8_HAS_AVX512VBMI 1
+#endif
+#endif
+
+#ifndef IS_UTF8_HAS_AVX512VBMI2
+#if defined(__AVX512VBMI2__) && __AVX512VBMI2__ == 1
+#define IS_UTF8_HAS_AVX512VBMI2 1
+#endif
+#endif
+
+#ifndef IS_UTF8_HAS_AVX512VNNI
+#if defined(__AVX512VNNI__) && __AVX512VNNI__ == 1
+#define IS_UTF8_HAS_AVX512VNNI 1
+#endif
+#endif
+
+#ifndef IS_UTF8_HAS_AVX512BITALG
+#if defined(__AVX512BITALG__) && __AVX512BITALG__ == 1
+#define IS_UTF8_HAS_AVX512BITALG 1
+#endif
+#endif
+
+#ifndef IS_UTF8_HAS_AVX512VPOPCNTDQ
+#if defined(__AVX512VPOPCNTDQ__) && __AVX512VPOPCNTDQ__ == 1
+#define IS_UTF8_HAS_AVX512VPOPCNTDQ 1
+#endif
+#endif
+
+#endif // IS_UTF8_AVX512_H_
+
+#if defined(__GNUC__)
+// Marks a block with a name so that MCA analysis can see it.
+#define IS_UTF8_BEGIN_DEBUG_BLOCK(name)                                        \
+  __asm volatile("# LLVM-MCA-BEGIN " #name);
+#define IS_UTF8_END_DEBUG_BLOCK(name) __asm volatile("# LLVM-MCA-END " #name);
+#define IS_UTF8_DEBUG_BLOCK(name, block)                                       \
+  BEGIN_DEBUG_BLOCK(name);                                                     \
+  block;                                                                       \
+  END_DEBUG_BLOCK(name);
+#else
+#define IS_UTF8_BEGIN_DEBUG_BLOCK(name)
+#define IS_UTF8_END_DEBUG_BLOCK(name)
+#define IS_UTF8_DEBUG_BLOCK(name, block)
+#endif
+
+// Align to N-byte boundary
+#define IS_UTF8_ROUNDUP_N(a, n) (((a) + ((n)-1)) & ~((n)-1))
+#define IS_UTF8_ROUNDDOWN_N(a, n) ((a) & ~((n)-1))
+
+#define IS_UTF8_ISALIGNED_N(ptr, n) (((uintptr_t)(ptr) & ((n)-1)) == 0)
+
+#if defined(IS_UTF8_REGULAR_VISUAL_STUDIO)
+
+#define is_utf8_really_inline __forceinline
+#define is_utf8_never_inline __declspec(noinline)
+
+#define is_utf8_unused
+#define is_utf8_warn_unused
+
+#ifndef is_utf8_likely
+#define is_utf8_likely(x) x
+#endif
+#ifndef is_utf8_unlikely
+#define is_utf8_unlikely(x) x
+#endif
+
+#define IS_UTF8_PUSH_DISABLE_WARNINGS __pragma(warning(push))
+#define IS_UTF8_PUSH_DISABLE_ALL_WARNINGS __pragma(warning(push, 0))
+#define IS_UTF8_DISABLE_VS_WARNING(WARNING_NUMBER)                             \
+  __pragma(warning(disable : WARNING_NUMBER))
+// Get rid of Intellisense-only warnings (Code Analysis)
+// Though __has_include is C++17, it is supported in Visual Studio 2017 or
+// better (_MSC_VER>=1910).
+#ifdef __has_include
+#if __has_include(<CppCoreCheck\Warnings.h>)
+#include <CppCoreCheck\Warnings.h>
+#define IS_UTF8_DISABLE_UNDESIRED_WARNINGS                                     \
+  IS_UTF8_DISABLE_VS_WARNING(ALL_CPPCORECHECK_WARNINGS)
+#endif
+#endif
+
+#ifndef IS_UTF8_DISABLE_UNDESIRED_WARNINGS
+#define IS_UTF8_DISABLE_UNDESIRED_WARNINGS
+#endif
+
+#define IS_UTF8_DISABLE_DEPRECATED_WARNING IS_UTF8_DISABLE_VS_WARNING(4996)
+#define IS_UTF8_DISABLE_STRICT_OVERFLOW_WARNING
+#define IS_UTF8_POP_DISABLE_WARNINGS __pragma(warning(pop))
+
+#else // IS_UTF8_REGULAR_VISUAL_STUDIO
+
+#define is_utf8_really_inline inline __attribute__((always_inline))
+#define is_utf8_never_inline inline __attribute__((noinline))
+
+#define is_utf8_unused __attribute__((unused))
+#define is_utf8_warn_unused __attribute__((warn_unused_result))
+
+#ifndef is_utf8_likely
+#define is_utf8_likely(x) __builtin_expect(!!(x), 1)
+#endif
+#ifndef is_utf8_unlikely
+#define is_utf8_unlikely(x) __builtin_expect(!!(x), 0)
+#endif
+
+#define IS_UTF8_PUSH_DISABLE_WARNINGS _Pragma("GCC diagnostic push")
+// gcc doesn't seem to disable all warnings with all and extra, add warnings
+// here as necessary
+#define IS_UTF8_PUSH_DISABLE_ALL_WARNINGS                                      \
+  IS_UTF8_PUSH_DISABLE_WARNINGS                                                \
+  IS_UTF8_DISABLE_GCC_WARNING(-Weffc++)                                        \
+  IS_UTF8_DISABLE_GCC_WARNING(-Wall)                                           \
+  IS_UTF8_DISABLE_GCC_WARNING(-Wconversion)                                    \
+  IS_UTF8_DISABLE_GCC_WARNING(-Wextra)                                         \
+  IS_UTF8_DISABLE_GCC_WARNING(-Wattributes)                                    \
+  IS_UTF8_DISABLE_GCC_WARNING(-Wimplicit-fallthrough)                        \
+  IS_UTF8_DISABLE_GCC_WARNING(-Wnon-virtual-dtor)                          \
+  IS_UTF8_DISABLE_GCC_WARNING(-Wreturn-type)                                 \
+  IS_UTF8_DISABLE_GCC_WARNING(-Wshadow)                                        \
+  IS_UTF8_DISABLE_GCC_WARNING(-Wunused-parameter)                            \
+  IS_UTF8_DISABLE_GCC_WARNING(-Wunused-variable)
+#define IS_UTF8_PRAGMA(P) _Pragma(#P)
+#define IS_UTF8_DISABLE_GCC_WARNING(WARNING)                                   \
+  IS_UTF8_PRAGMA(GCC diagnostic ignored #WARNING)
+#if defined(IS_UTF8_CLANG_VISUAL_STUDIO)
+#define IS_UTF8_DISABLE_UNDESIRED_WARNINGS                                     \
+  IS_UTF8_DISABLE_GCC_WARNING(-Wmicrosoft-include)
+#else
+#define IS_UTF8_DISABLE_UNDESIRED_WARNINGS
+#endif
+#define IS_UTF8_DISABLE_DEPRECATED_WARNING                                     \
+  IS_UTF8_DISABLE_GCC_WARNING(-Wdeprecated-declarations)
+#define IS_UTF8_DISABLE_STRICT_OVERFLOW_WARNING                                \
+  IS_UTF8_DISABLE_GCC_WARNING(-Wstrict-overflow)
+#define IS_UTF8_POP_DISABLE_WARNINGS _Pragma("GCC diagnostic pop")
+
+#endif // MSC_VER
+
+#if defined(IS_UTF8_VISUAL_STUDIO)
+/**
+ * It does not matter here whether you are using
+ * the regular visual studio or clang under visual
+ * studio.
+ */
+#if IS_UTF8_USING_LIBRARY
+#define IS_UTF8_DLLIMPORTEXPORT __declspec(dllimport)
+#else
+#define IS_UTF8_DLLIMPORTEXPORT __declspec(dllexport)
+#endif
+#else
+#define IS_UTF8_DLLIMPORTEXPORT
+#endif
+
+/// If EXPR is an error, returns it.
+#define IS_UTF8_TRY(EXPR)                                                      \
+  {                                                                            \
+    auto _err = (EXPR);                                                        \
+    if (_err) {                                                                \
+      return _err;                                                             \
+    }                                                                          \
+  }
+
+#endif // IS_UTF8_COMMON_DEFS_H
+#include <string>
+
+namespace is_utf8_internals {
+
+enum encoding_type {
+  UTF8 = 1,      // BOM 0xef 0xbb 0xbf
+  UTF16_LE = 2,  // BOM 0xff 0xfe
+  UTF16_BE = 4,  // BOM 0xfe 0xff
+  UTF32_LE = 8,  // BOM 0xff 0xfe 0x00 0x00
+  UTF32_BE = 16, // BOM 0x00 0x00 0xfe 0xff
+
+  unspecified = 0
+};
+
+enum endianness { LITTLE, BIG };
+
+std::string to_string(encoding_type bom);
+
+// Note that BOM for UTF8 is discouraged.
+namespace BOM {
+
+/**
+ * Checks for a BOM. If not, returns unspecified
+ * @param input         the string to process
+ * @param length        the length of the string in words
+ * @return the corresponding encoding
+ */
+
+encoding_type check_bom(const uint8_t *byte, size_t length);
+encoding_type check_bom(const char *byte, size_t length);
+/**
+ * Returns the size, in bytes, of the BOM for a given encoding type.
+ * Note that UTF8 BOM are discouraged.
+ * @param bom         the encoding type
+ * @return the size in bytes of the corresponding BOM
+ */
+size_t bom_byte_size(encoding_type bom);
+
+} // namespace BOM
+} // namespace is_utf8_internals
+#ifndef ERROR_H
+#define ERROR_H
+namespace is_utf8_internals {
+
+enum error_code {
+  SUCCESS = 0,
+  HEADER_BITS, // Any byte must have fewer than 5 header bits.
+  TOO_SHORT,   // The leading byte must be followed by N-1 continuation bytes,
+             // where N is the UTF-8 character length This is also the error
+             // when the input is truncated.
+  TOO_LONG, // The leading byte must not be a continuation byte.
+  OVERLONG, // The decoded character must be above U+7F for two-byte characters,
+            // U+7FF for three-byte characters, and U+FFFF for four-byte
+            // characters.
+  TOO_LARGE, // The decoded character must be less than or equal to U+10FFFF OR
+             // less than or equal than U+7F for ASCII.
+  SURROGATE, // The decoded character must be not be in U+D800...DFFF (UTF-8 or
+             // UTF-32) OR a high surrogate must be followed by a low surrogate
+             // and a low surrogate must be preceded by a high surrogate
+             // (UTF-16)
+  OTHER // Not related to validation/transcoding.
+};
+
+struct result {
+  error_code error;
+  size_t
+      count; // In case of error, indicates the position of the error. In case
+             // of success, indicates the number of words validated/written.
+
+  is_utf8_really_inline result();
+
+  is_utf8_really_inline result(error_code, size_t);
+};
+
+} // namespace is_utf8_internals
+#endif
+
+IS_UTF8_PUSH_DISABLE_WARNINGS
+IS_UTF8_DISABLE_UNDESIRED_WARNINGS
+
+#ifndef IS_UTF8_IMPLEMENTATION_H
+#define IS_UTF8_IMPLEMENTATION_H
+#include <string>
+#if !defined(IS_UTF8_NO_THREADS)
+#include <atomic>
+#endif
+#include <tuple>
+#include <vector>
+/* From
+https://github.com/endorno/pytorch/blob/master/torch/lib/TH/generic/simd/simd.h
+Highly modified.
+
+Copyright (c) 2016-     Facebook, Inc            (Adam Paszke)
+Copyright (c) 2014-     Facebook, Inc            (Soumith Chintala)
+Copyright (c) 2011-2014 Idiap Research Institute (Ronan Collobert)
+Copyright (c) 2012-2014 Deepmind Technologies    (Koray Kavukcuoglu)
+Copyright (c) 2011-2012 NEC Laboratories America (Koray Kavukcuoglu)
+Copyright (c) 2011-2013 NYU                      (Clement Farabet)
+Copyright (c) 2006-2010 NEC Laboratories America (Ronan Collobert, Leon Bottou,
+Iain Melvin, Jason Weston) Copyright (c) 2006      Idiap Research Institute
+(Samy Bengio) Copyright (c) 2001-2004 Idiap Research Institute (Ronan Collobert,
+Samy Bengio, Johnny Mariethoz)
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+
+3. Neither the names of Facebook, Deepmind Technologies, NYU, NEC Laboratories
+America and IDIAP Research Institute nor the names of its contributors may be
+   used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#ifndef IS_UTF8_INTERNAL_ISADETECTION_H
+#define IS_UTF8_INTERNAL_ISADETECTION_H
+
+#include <cstdint>
+#include <cstdlib>
+#if defined(_MSC_VER)
+#include <intrin.h>
+#elif defined(HAVE_GCC_GET_CPUID) && defined(USE_GCC_GET_CPUID)
+#include <cpuid.h>
+#endif
+
+namespace is_utf8_internals {
+namespace internal {
+
+enum instruction_set {
+  DEFAULT = 0x0,
+  NEON = 0x1,
+  AVX2 = 0x4,
+  SSE42 = 0x8,
+  PCLMULQDQ = 0x10,
+  BMI1 = 0x20,
+  BMI2 = 0x40,
+  ALTIVEC = 0x80,
+  AVX512F = 0x100,
+  AVX512DQ = 0x200,
+  AVX512IFMA = 0x400,
+  AVX512PF = 0x800,
+  AVX512ER = 0x1000,
+  AVX512CD = 0x2000,
+  AVX512BW = 0x4000,
+  AVX512VL = 0x8000,
+  AVX512VBMI2 = 0x10000
+};
+
+#if defined(__PPC64__)
+
+static inline uint32_t detect_supported_architectures() {
+  return instruction_set::ALTIVEC;
+}
+
+#elif defined(__arm__) || defined(__aarch64__) // incl. armel, armhf, arm64
+
+#if defined(__ARM_NEON)
+
+static inline uint32_t detect_supported_architectures() {
+  return instruction_set::NEON;
+}
+
+#else // ARM without NEON
+
+static inline uint32_t detect_supported_architectures() {
+  return instruction_set::DEFAULT;
+}
+
+#endif
+
+#elif defined(__x86_64__) || defined(_M_AMD64) // x64
+
+namespace {
+namespace cpuid_bit {
+// Can be found on Intel ISA Reference for CPUID
+
+// EAX = 0x01
+constexpr uint32_t pclmulqdq = uint32_t(1)
+                               << 1; ///< @private bit  1 of ECX for EAX=0x1
+constexpr uint32_t sse42 = uint32_t(1)
+                           << 20; ///< @private bit 20 of ECX for EAX=0x1
+
+// EAX = 0x7f (Structured Extended Feature Flags), ECX = 0x00 (Sub-leaf)
+// See: "Table 3-8. Information Returned by CPUID Instruction"
+namespace ebx {
+constexpr uint32_t bmi1 = uint32_t(1) << 3;
+constexpr uint32_t avx2 = uint32_t(1) << 5;
+constexpr uint32_t bmi2 = uint32_t(1) << 8;
+constexpr uint32_t avx512f = uint32_t(1) << 16;
+constexpr uint32_t avx512dq = uint32_t(1) << 17;
+constexpr uint32_t avx512cd = uint32_t(1) << 28;
+constexpr uint32_t avx512bw = uint32_t(1) << 30;
+constexpr uint32_t avx512vl = uint32_t(1) << 31;
+} // namespace ebx
+
+namespace ecx {
+constexpr uint32_t avx512vbmi2 = uint32_t(1) << 6;
+} // namespace ecx
+} // namespace cpuid_bit
+} // namespace
+
+static inline void cpuid(uint32_t *eax, uint32_t *ebx, uint32_t *ecx,
+                         uint32_t *edx) {
+#if defined(_MSC_VER)
+  int cpu_info[4];
+  __cpuid(cpu_info, *eax);
+  *eax = cpu_info[0];
+  *ebx = cpu_info[1];
+  *ecx = cpu_info[2];
+  *edx = cpu_info[3];
+#elif defined(HAVE_GCC_GET_CPUID) && defined(USE_GCC_GET_CPUID)
+  uint32_t level = *eax;
+  __get_cpuid(level, eax, ebx, ecx, edx);
+#else
+  uint32_t a = *eax, b, c = *ecx, d;
+  asm volatile("cpuid\n\t" : "+a"(a), "=b"(b), "+c"(c), "=d"(d));
+  *eax = a;
+  *ebx = b;
+  *ecx = c;
+  *edx = d;
+#endif
+}
+
+static inline uint32_t detect_supported_architectures() {
+  uint32_t eax;
+  uint32_t ebx = 0;
+  uint32_t ecx = 0;
+  uint32_t edx = 0;
+  uint32_t host_isa = 0x0;
+
+  // EBX for EAX=0x1
+  eax = 0x1;
+  cpuid(&eax, &ebx, &ecx, &edx);
+
+  if (ecx & cpuid_bit::sse42) {
+    host_isa |= instruction_set::SSE42;
+  }
+
+  if (ecx & cpuid_bit::pclmulqdq) {
+    host_isa |= instruction_set::PCLMULQDQ;
+  }
+
+  // ECX for EAX=0x7
+  eax = 0x7;
+  ecx = 0x0; // Sub-leaf = 0
+  cpuid(&eax, &ebx, &ecx, &edx);
+  if (ebx & cpuid_bit::ebx::avx2) {
+    host_isa |= instruction_set::AVX2;
+  }
+  if (ebx & cpuid_bit::ebx::bmi1) {
+    host_isa |= instruction_set::BMI1;
+  }
+  if (ebx & cpuid_bit::ebx::bmi2) {
+    host_isa |= instruction_set::BMI2;
+  }
+  if (ebx & cpuid_bit::ebx::avx512f) {
+    host_isa |= instruction_set::AVX512F;
+  }
+  if (ebx & cpuid_bit::ebx::avx512bw) {
+    host_isa |= instruction_set::AVX512BW;
+  }
+  if (ebx & cpuid_bit::ebx::avx512cd) {
+    host_isa |= instruction_set::AVX512CD;
+  }
+  if (ebx & cpuid_bit::ebx::avx512dq) {
+    host_isa |= instruction_set::AVX512DQ;
+  }
+  if (ebx & cpuid_bit::ebx::avx512vl) {
+    host_isa |= instruction_set::AVX512VL;
+  }
+  if (ecx & cpuid_bit::ecx::avx512vbmi2) {
+    host_isa |= instruction_set::AVX512VBMI2;
+  }
+  return host_isa;
+}
+#else // fallback
+
+static inline uint32_t detect_supported_architectures() {
+  return instruction_set::DEFAULT;
+}
+
+#endif // end SIMD extension detection code
+
+} // namespace internal
+} // namespace is_utf8_internals
+
+#endif // IS_UTF8_INTERNAL_ISADETECTION_H
+
+namespace is_utf8_internals {
+
+/**
+ * Validate the UTF-8 string. This function may be best when you expect
+ * the input to be almost always valid. Otherwise, consider using
+ * validate_utf8_with_errors.
+ *
+ * Overridden by each implementation.
+ *
+ * @param buf the UTF-8 string to validate.
+ * @param len the length of the string in bytes.
+ * @return true if and only if the string is valid UTF-8.
+ */
+bool validate_utf8(const char *buf, size_t len) noexcept;
+
+class implementation {
+public:
+  virtual const std::string &name() const { return _name; }
+
+  virtual const std::string &description() const { return _description; }
+
+  bool supported_by_runtime_system() const;
+
+  virtual uint32_t required_instruction_sets() const {
+    return _required_instruction_sets;
+  };
+
+  /**
+   * Validate the UTF-8 string.
+   *
+   * Overridden by each implementation.
+   *
+   * @param buf the UTF-8 string to validate.
+   * @param len the length of the string in bytes.
+   * @return true if and only if the string is valid UTF-8.
+   */
+  is_utf8_warn_unused virtual bool validate_utf8(const char *buf,
+                                                 size_t len) const noexcept = 0;
+
+protected:
+  /** @private Construct an implementation with the given name and description.
+   * For subclasses. */
+  is_utf8_really_inline implementation(std::string name,
+                                       std::string description,
+                                       uint32_t required_instruction_sets)
+      : _name(name), _description(description),
+        _required_instruction_sets(required_instruction_sets) {}
+  virtual ~implementation() = default;
+
+private:
+  /**
+   * The name of this implementation.
+   */
+  const std::string _name;
+
+  /**
+   * The description of this implementation.
+   */
+  const std::string _description;
+
+  /**
+   * Instruction sets required for this implementation.
+   */
+  const uint32_t _required_instruction_sets;
+};
+
+/** @private */
+namespace internal {
+
+class available_implementation_list {
+public:
+  /** Get the list of available implementations */
+  is_utf8_really_inline available_implementation_list() {}
+  /** Number of implementations */
+  size_t size() const noexcept;
+  /** STL const begin() iterator */
+  const implementation *const *begin() const noexcept;
+  /** STL const end() iterator */
+  const implementation *const *end() const noexcept;
+
+  /**
+   * Get the implementation with the given name.
+   *
+   * Case sensitive.
+   *
+   *     const implementation *impl =
+   * is_utf8_internals::available_implementations["westmere"]; if (!impl) {
+   * exit(1); } if (!imp->supported_by_runtime_system()) { exit(1); }
+   *     is_utf8_internals::active_implementation = impl;
+   *
+   * @param name the implementation to find, e.g. "westmere", "haswell", "arm64"
+   * @return the implementation, or nullptr if the parse failed.
+   */
+  const implementation *operator[](const std::string &name) const noexcept {
+    for (const implementation *impl : *this) {
+      if (impl->name() == name) {
+        return impl;
+      }
+    }
+    return nullptr;
+  }
+
+  /**
+   * Detect the most advanced implementation supported by the current host.
+   *
+   * This is used to initialize the implementation on startup.
+   *
+   *     const implementation *impl =
+   * is_utf8_internals::available_implementation::detect_best_supported();
+   *     is_utf8_internals::active_implementation = impl;
+   *
+   * @return the most advanced supported implementation for the current host, or
+   * an implementation that returns UNSUPPORTED_ARCHITECTURE if there is no
+   * supported implementation. Will never return nullptr.
+   */
+  const implementation *detect_best_supported() const noexcept;
+};
+
+template <typename T> class atomic_ptr {
+public:
+  atomic_ptr(T *_ptr) : ptr{_ptr} {}
+
+#if defined(IS_UTF8_NO_THREADS)
+  operator const T *() const { return ptr; }
+  const T &operator*() const { return *ptr; }
+  const T *operator->() const { return ptr; }
+
+  operator T *() { return ptr; }
+  T &operator*() { return *ptr; }
+  T *operator->() { return ptr; }
+  atomic_ptr &operator=(T *_ptr) {
+    ptr = _ptr;
+    return *this;
+  }
+
+#else
+  operator const T *() const { return ptr.load(); }
+  const T &operator*() const { return *ptr; }
+  const T *operator->() const { return ptr.load(); }
+
+  operator T *() { return ptr.load(); }
+  T &operator*() { return *ptr; }
+  T *operator->() { return ptr.load(); }
+  atomic_ptr &operator=(T *_ptr) {
+    ptr = _ptr;
+    return *this;
+  }
+
+#endif
+
+private:
+#if defined(IS_UTF8_NO_THREADS)
+  T *ptr;
+#else
+  std::atomic<T *> ptr;
+#endif
+};
+
+} // namespace internal
+
+/**
+ * The list of available implementations compiled into simdutf.
+ */
+extern IS_UTF8_DLLIMPORTEXPORT const internal::available_implementation_list
+    available_implementations;
+
+/**
+ * The active implementation.
+ *
+ * Automatically initialized on first use to the most advanced implementation
+ * supported by this hardware.
+ */
+extern IS_UTF8_DLLIMPORTEXPORT internal::atomic_ptr<const implementation>
+    active_implementation;
+
+} // namespace is_utf8_internals
+
+#endif // IS_UTF8_IMPLEMENTATION_H
+
+// Implementation-internal files (must be included before the implementations
+// themselves, to keep amalgamation working--otherwise, the first time a file is
+// included, it might be put inside the #ifdef
+// IS_UTF8_IMPLEMENTATION_ARM64/FALLBACK/etc., which means the other
+// implementations can't compile unless that implementation is turned on).
+
+IS_UTF8_POP_DISABLE_WARNINGS
+
+#endif // IS_UTF8_H
+
+#include <climits>
+#include <initializer_list>
+
+// Useful for debugging purposes
+namespace is_utf8_internals {
+namespace {
+
+template <typename T> std::string toBinaryString(T b) {
+  std::string binary = "";
+  T mask = T(1) << (sizeof(T) * CHAR_BIT - 1);
+  while (mask > 0) {
+    binary += ((b & mask) == 0) ? '0' : '1';
+    mask >>= 1;
+  }
+  return binary;
+}
+} // namespace
+} // namespace is_utf8_internals
+
+// Implementations
+// The best choice should always come first!
+
+#ifndef IS_UTF8_ARM64_H
+#define IS_UTF8_ARM64_H
+
+#ifdef IS_UTF8_FALLBACK_H
+#error "arm64.h must be included before fallback.h"
+#endif
+
+#ifndef IS_UTF8_IMPLEMENTATION_ARM64
+#define IS_UTF8_IMPLEMENTATION_ARM64 (IS_UTF8_IS_ARM64)
+#endif
+#define IS_UTF8_CAN_ALWAYS_RUN_ARM64                                           \
+  IS_UTF8_IMPLEMENTATION_ARM64 &&IS_UTF8_IS_ARM64
+
+#if IS_UTF8_IMPLEMENTATION_ARM64
+
+namespace is_utf8_internals {
+/**
+ * Implementation for NEON (ARMv8).
+ */
+namespace arm64 {} // namespace arm64
+} // namespace is_utf8_internals
+
+#ifndef IS_UTF8_ARM64_IMPLEMENTATION_H
+#define IS_UTF8_ARM64_IMPLEMENTATION_H
+
+namespace is_utf8_internals {
+namespace arm64 {
+
+class implementation final : public is_utf8_internals::implementation {
+public:
+  is_utf8_really_inline implementation()
+      : is_utf8_internals::implementation("arm64", "ARM NEON",
+                                          internal::instruction_set::NEON) {}
+  is_utf8_warn_unused bool validate_utf8(const char *buf,
+                                         size_t len) const noexcept final;
+};
+
+} // namespace arm64
+} // namespace is_utf8_internals
+
+#endif // IS_UTF8_ARM64_IMPLEMENTATION_H
+
+// redefining IS_UTF8_IMPLEMENTATION to "arm64"
+// #define IS_UTF8_IMPLEMENTATION arm64
+
+// Declarations
+
+#ifndef IS_UTF8_ARM64_INTRINSICS_H
+#define IS_UTF8_ARM64_INTRINSICS_H
+
+// This should be the correct header whether
+// you use visual studio or other compilers.
+#include <arm_neon.h>
+
+#endif //  IS_UTF8_ARM64_INTRINSICS_H
+
+#ifndef IS_UTF8_ARM64_BITMANIPULATION_H
+#define IS_UTF8_ARM64_BITMANIPULATION_H
+
+namespace is_utf8_internals {
+namespace arm64 {
+namespace {} // unnamed namespace
+} // namespace arm64
+} // namespace is_utf8_internals
+
+#endif // IS_UTF8_ARM64_BITMANIPULATION_H
+
+#ifndef IS_UTF8_ARM64_SIMD_H
+#define IS_UTF8_ARM64_SIMD_H
+
+#include <type_traits>
+
+namespace is_utf8_internals {
+namespace arm64 {
+namespace {
+namespace simd {
+
+#ifdef IS_UTF8_REGULAR_VISUAL_STUDIO
+namespace {
+// Start of private section with Visual Studio workaround
+
+/**
+ * make_uint8x16_t initializes a SIMD register (uint8x16_t).
+ * This is needed because, incredibly, the syntax uint8x16_t x = {1,2,3...}
+ * is not recognized under Visual Studio! This is a workaround.
+ * Using a std::initializer_list<uint8_t>  as a parameter resulted in
+ * inefficient code. With the current approach, if the parameters are
+ * compile-time constants,
+ * GNU GCC compiles it to ldr, the same as uint8x16_t x = {1,2,3...}.
+ * You should not use this function except for compile-time constants:
+ * it is not efficient.
+ */
+is_utf8_really_inline uint8x16_t make_uint8x16_t(
+    uint8_t x1, uint8_t x2, uint8_t x3, uint8_t x4, uint8_t x5, uint8_t x6,
+    uint8_t x7, uint8_t x8, uint8_t x9, uint8_t x10, uint8_t x11, uint8_t x12,
+    uint8_t x13, uint8_t x14, uint8_t x15, uint8_t x16) {
+  // Doing a load like so end ups generating worse code.
+  // uint8_t array[16] = {x1, x2, x3, x4, x5, x6, x7, x8,
+  //                     x9, x10,x11,x12,x13,x14,x15,x16};
+  // return vld1q_u8(array);
+  uint8x16_t x{};
+  // incredibly, Visual Studio does not allow x[0] = x1
+  x = vsetq_lane_u8(x1, x, 0);
+  x = vsetq_lane_u8(x2, x, 1);
+  x = vsetq_lane_u8(x3, x, 2);
+  x = vsetq_lane_u8(x4, x, 3);
+  x = vsetq_lane_u8(x5, x, 4);
+  x = vsetq_lane_u8(x6, x, 5);
+  x = vsetq_lane_u8(x7, x, 6);
+  x = vsetq_lane_u8(x8, x, 7);
+  x = vsetq_lane_u8(x9, x, 8);
+  x = vsetq_lane_u8(x10, x, 9);
+  x = vsetq_lane_u8(x11, x, 10);
+  x = vsetq_lane_u8(x12, x, 11);
+  x = vsetq_lane_u8(x13, x, 12);
+  x = vsetq_lane_u8(x14, x, 13);
+  x = vsetq_lane_u8(x15, x, 14);
+  x = vsetq_lane_u8(x16, x, 15);
+  return x;
+}
+
+// We have to do the same work for make_int8x16_t
+is_utf8_really_inline int8x16_t
+make_int8x16_t(int8_t x1, int8_t x2, int8_t x3, int8_t x4, int8_t x5, int8_t x6,
+               int8_t x7, int8_t x8, int8_t x9, int8_t x10, int8_t x11,
+               int8_t x12, int8_t x13, int8_t x14, int8_t x15, int8_t x16) {
+  // Doing a load like so end ups generating worse code.
+  // int8_t array[16] = {x1, x2, x3, x4, x5, x6, x7, x8,
+  //                     x9, x10,x11,x12,x13,x14,x15,x16};
+  // return vld1q_s8(array);
+  int8x16_t x{};
+  // incredibly, Visual Studio does not allow x[0] = x1
+  x = vsetq_lane_s8(x1, x, 0);
+  x = vsetq_lane_s8(x2, x, 1);
+  x = vsetq_lane_s8(x3, x, 2);
+  x = vsetq_lane_s8(x4, x, 3);
+  x = vsetq_lane_s8(x5, x, 4);
+  x = vsetq_lane_s8(x6, x, 5);
+  x = vsetq_lane_s8(x7, x, 6);
+  x = vsetq_lane_s8(x8, x, 7);
+  x = vsetq_lane_s8(x9, x, 8);
+  x = vsetq_lane_s8(x10, x, 9);
+  x = vsetq_lane_s8(x11, x, 10);
+  x = vsetq_lane_s8(x12, x, 11);
+  x = vsetq_lane_s8(x13, x, 12);
+  x = vsetq_lane_s8(x14, x, 13);
+  x = vsetq_lane_s8(x15, x, 14);
+  x = vsetq_lane_s8(x16, x, 15);
+  return x;
+}
+
+is_utf8_really_inline uint8x8_t make_uint8x8_t(uint8_t x1, uint8_t x2,
+                                               uint8_t x3, uint8_t x4,
+                                               uint8_t x5, uint8_t x6,
+                                               uint8_t x7, uint8_t x8) {
+  uint8x8_t x{};
+  x = vset_lane_u8(x1, x, 0);
+  x = vset_lane_u8(x2, x, 1);
+  x = vset_lane_u8(x3, x, 2);
+  x = vset_lane_u8(x4, x, 3);
+  x = vset_lane_u8(x5, x, 4);
+  x = vset_lane_u8(x6, x, 5);
+  x = vset_lane_u8(x7, x, 6);
+  x = vset_lane_u8(x8, x, 7);
+  return x;
+}
+
+is_utf8_really_inline uint16x8_t make_uint16x8_t(uint16_t x1, uint16_t x2,
+                                                 uint16_t x3, uint16_t x4,
+                                                 uint16_t x5, uint16_t x6,
+                                                 uint16_t x7, uint16_t x8) {
+  uint16x8_t x{};
+  x = vsetq_lane_u16(x1, x, 0);
+  x = vsetq_lane_u16(x2, x, 1);
+  x = vsetq_lane_u16(x3, x, 2);
+  x = vsetq_lane_u16(x4, x, 3);
+  x = vsetq_lane_u16(x5, x, 4);
+  x = vsetq_lane_u16(x6, x, 5);
+  x = vsetq_lane_u16(x7, x, 6);
+  x = vsetq_lane_u16(x8, x, 7);
+  ;
+  return x;
+}
+
+is_utf8_really_inline int16x8_t make_int16x8_t(int16_t x1, int16_t x2,
+                                               int16_t x3, int16_t x4,
+                                               int16_t x5, int16_t x6,
+                                               int16_t x7, int16_t x8) {
+  uint16x8_t x{};
+  x = vsetq_lane_s16(x1, x, 0);
+  x = vsetq_lane_s16(x2, x, 1);
+  x = vsetq_lane_s16(x3, x, 2);
+  x = vsetq_lane_s16(x4, x, 3);
+  x = vsetq_lane_s16(x5, x, 4);
+  x = vsetq_lane_s16(x6, x, 5);
+  x = vsetq_lane_s16(x7, x, 6);
+  x = vsetq_lane_s16(x8, x, 7);
+  ;
+  return x;
+}
+
+// End of private section with Visual Studio workaround
+} // namespace
+#endif // IS_UTF8_REGULAR_VISUAL_STUDIO
+
+template <typename T> struct simd8;
+
+//
+// Base class of simd8<uint8_t> and simd8<bool>, both of which use uint8x16_t
+// internally.
+//
+template <typename T, typename Mask = simd8<bool>> struct base_u8 {
+  uint8x16_t value;
+  static const int SIZE = sizeof(value);
+
+  // Conversion from/to SIMD register
+  is_utf8_really_inline base_u8(const uint8x16_t _value) : value(_value) {}
+  is_utf8_really_inline operator const uint8x16_t &() const {
+    return this->value;
+  }
+  is_utf8_really_inline operator uint8x16_t &() { return this->value; }
+  is_utf8_really_inline T first() const { return vgetq_lane_u8(*this, 0); }
+  is_utf8_really_inline T last() const { return vgetq_lane_u8(*this, 15); }
+
+  // Bit operations
+  is_utf8_really_inline simd8<T> operator|(const simd8<T> other) const {
+    return vorrq_u8(*this, other);
+  }
+  is_utf8_really_inline simd8<T> operator&(const simd8<T> other) const {
+    return vandq_u8(*this, other);
+  }
+  is_utf8_really_inline simd8<T> operator^(const simd8<T> other) const {
+    return veorq_u8(*this, other);
+  }
+  is_utf8_really_inline simd8<T> bit_andnot(const simd8<T> other) const {
+    return vbicq_u8(*this, other);
+  }
+  is_utf8_really_inline simd8<T> operator~() const { return *this ^ 0xFFu; }
+  is_utf8_really_inline simd8<T> &operator|=(const simd8<T> other) {
+    auto this_cast = static_cast<simd8<T> *>(this);
+    *this_cast = *this_cast | other;
+    return *this_cast;
+  }
+  is_utf8_really_inline simd8<T> &operator&=(const simd8<T> other) {
+    auto this_cast = static_cast<simd8<T> *>(this);
+    *this_cast = *this_cast & other;
+    return *this_cast;
+  }
+  is_utf8_really_inline simd8<T> &operator^=(const simd8<T> other) {
+    auto this_cast = static_cast<simd8<T> *>(this);
+    *this_cast = *this_cast ^ other;
+    return *this_cast;
+  }
+
+  is_utf8_really_inline Mask operator==(const simd8<T> other) const {
+    return vceqq_u8(*this, other);
+  }
+
+  template <int N = 1>
+  is_utf8_really_inline simd8<T> prev(const simd8<T> prev_chunk) const {
+    return vextq_u8(prev_chunk, *this, 16 - N);
+  }
+};
+
+// SIMD byte mask type (returned by things like eq and gt)
+template <> struct simd8<bool> : base_u8<bool> {
+  typedef uint16_t bitmask_t;
+  typedef uint32_t bitmask2_t;
+
+  static is_utf8_really_inline simd8<bool> splat(bool _value) {
+    return vmovq_n_u8(uint8_t(-(!!_value)));
+  }
+
+  is_utf8_really_inline simd8(const uint8x16_t _value)
+      : base_u8<bool>(_value) {}
+  // False constructor
+  is_utf8_really_inline simd8() : simd8(vdupq_n_u8(0)) {}
+  // Splat constructor
+  is_utf8_really_inline simd8(bool _value) : simd8(splat(_value)) {}
+  is_utf8_really_inline void store(uint8_t dst[16]) const {
+    return vst1q_u8(dst, *this);
+  }
+
+  // We return uint32_t instead of uint16_t because that seems to be more
+  // efficient for most purposes (cutting it down to uint16_t costs performance
+  // in some compilers).
+  is_utf8_really_inline uint32_t to_bitmask() const {
+#ifdef IS_UTF8_REGULAR_VISUAL_STUDIO
+    const uint8x16_t bit_mask =
+        make_uint8x16_t(0x01, 0x02, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80, 0x01,
+                        0x02, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80);
+#else
+    const uint8x16_t bit_mask = {0x01, 0x02, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80,
+                                 0x01, 0x02, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80};
+#endif
+    auto minput = *this & bit_mask;
+    uint8x16_t tmp = vpaddq_u8(minput, minput);
+    tmp = vpaddq_u8(tmp, tmp);
+    tmp = vpaddq_u8(tmp, tmp);
+    return vgetq_lane_u16(vreinterpretq_u16_u8(tmp), 0);
+  }
+
+  // Returns 4-bit out of each byte, alternating between the high 4 bits and low
+  // bits result it is 64 bit. This method is expected to be faster than none()
+  // and is equivalent when the vector register is the result of a comparison,
+  // with byte values 0xff and 0x00.
+  is_utf8_really_inline uint64_t to_bitmask64() const {
+    return vget_lane_u64(
+        vreinterpret_u64_u8(vshrn_n_u16(vreinterpretq_u16_u8(*this), 4)), 0);
+  }
+
+  is_utf8_really_inline bool any() const { return vmaxvq_u8(*this) != 0; }
+  is_utf8_really_inline bool none() const { return vmaxvq_u8(*this) == 0; }
+  is_utf8_really_inline bool all() const { return vminvq_u8(*this) == 0xFF; }
+};
+
+// Unsigned bytes
+template <> struct simd8<uint8_t> : base_u8<uint8_t> {
+  static is_utf8_really_inline simd8<uint8_t> splat(uint8_t _value) {
+    return vmovq_n_u8(_value);
+  }
+  static is_utf8_really_inline simd8<uint8_t> zero() { return vdupq_n_u8(0); }
+  static is_utf8_really_inline simd8<uint8_t> load(const uint8_t *values) {
+    return vld1q_u8(values);
+  }
+  is_utf8_really_inline simd8(const uint8x16_t _value)
+      : base_u8<uint8_t>(_value) {}
+  // Zero constructor
+  is_utf8_really_inline simd8() : simd8(zero()) {}
+  // Array constructor
+  is_utf8_really_inline simd8(const uint8_t values[16]) : simd8(load(values)) {}
+  // Splat constructor
+  is_utf8_really_inline simd8(uint8_t _value) : simd8(splat(_value)) {}
+  // Member-by-member initialization
+#ifdef IS_UTF8_REGULAR_VISUAL_STUDIO
+  is_utf8_really_inline
+  simd8(uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3, uint8_t v4, uint8_t v5,
+        uint8_t v6, uint8_t v7, uint8_t v8, uint8_t v9, uint8_t v10,
+        uint8_t v11, uint8_t v12, uint8_t v13, uint8_t v14, uint8_t v15)
+      : simd8(make_uint8x16_t(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11,
+                              v12, v13, v14, v15)) {}
+#else
+  is_utf8_really_inline
+  simd8(uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3, uint8_t v4, uint8_t v5,
+        uint8_t v6, uint8_t v7, uint8_t v8, uint8_t v9, uint8_t v10,
+        uint8_t v11, uint8_t v12, uint8_t v13, uint8_t v14, uint8_t v15)
+      : simd8(uint8x16_t{v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12,
+                         v13, v14, v15}) {}
+#endif
+
+  // Repeat 16 values as many times as necessary (usually for lookup tables)
+  is_utf8_really_inline static simd8<uint8_t>
+  repeat_16(uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3, uint8_t v4,
+            uint8_t v5, uint8_t v6, uint8_t v7, uint8_t v8, uint8_t v9,
+            uint8_t v10, uint8_t v11, uint8_t v12, uint8_t v13, uint8_t v14,
+            uint8_t v15) {
+    return simd8<uint8_t>(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12,
+                          v13, v14, v15);
+  }
+
+  // Store to array
+  is_utf8_really_inline void store(uint8_t dst[16]) const {
+    return vst1q_u8(dst, *this);
+  }
+
+  // Saturated math
+  is_utf8_really_inline simd8<uint8_t>
+  saturating_add(const simd8<uint8_t> other) const {
+    return vqaddq_u8(*this, other);
+  }
+  is_utf8_really_inline simd8<uint8_t>
+  saturating_sub(const simd8<uint8_t> other) const {
+    return vqsubq_u8(*this, other);
+  }
+
+  // Addition/subtraction are the same for signed and unsigned
+  is_utf8_really_inline simd8<uint8_t>
+  operator+(const simd8<uint8_t> other) const {
+    return vaddq_u8(*this, other);
+  }
+  is_utf8_really_inline simd8<uint8_t>
+  operator-(const simd8<uint8_t> other) const {
+    return vsubq_u8(*this, other);
+  }
+  is_utf8_really_inline simd8<uint8_t> &operator+=(const simd8<uint8_t> other) {
+    *this = *this + other;
+    return *this;
+  }
+  is_utf8_really_inline simd8<uint8_t> &operator-=(const simd8<uint8_t> other) {
+    *this = *this - other;
+    return *this;
+  }
+
+  // Order-specific operations
+  is_utf8_really_inline uint8_t max_val() const { return vmaxvq_u8(*this); }
+  is_utf8_really_inline uint8_t min_val() const { return vminvq_u8(*this); }
+  is_utf8_really_inline simd8<uint8_t>
+  max_val(const simd8<uint8_t> other) const {
+    return vmaxq_u8(*this, other);
+  }
+  is_utf8_really_inline simd8<uint8_t>
+  min_val(const simd8<uint8_t> other) const {
+    return vminq_u8(*this, other);
+  }
+  is_utf8_really_inline simd8<bool>
+  operator<=(const simd8<uint8_t> other) const {
+    return vcleq_u8(*this, other);
+  }
+  is_utf8_really_inline simd8<bool>
+  operator>=(const simd8<uint8_t> other) const {
+    return vcgeq_u8(*this, other);
+  }
+  is_utf8_really_inline simd8<bool>
+  operator<(const simd8<uint8_t> other) const {
+    return vcltq_u8(*this, other);
+  }
+  is_utf8_really_inline simd8<bool>
+  operator>(const simd8<uint8_t> other) const {
+    return vcgtq_u8(*this, other);
+  }
+  // Same as >, but instead of guaranteeing all 1's == true, false = 0 and true
+  // = nonzero. For ARM, returns all 1's.
+  is_utf8_really_inline simd8<uint8_t>
+  gt_bits(const simd8<uint8_t> other) const {
+    return simd8<uint8_t>(*this > other);
+  }
+  // Same as <, but instead of guaranteeing all 1's == true, false = 0 and true
+  // = nonzero. For ARM, returns all 1's.
+  is_utf8_really_inline simd8<uint8_t>
+  lt_bits(const simd8<uint8_t> other) const {
+    return simd8<uint8_t>(*this < other);
+  }
+
+  // Bit-specific operations
+  is_utf8_really_inline simd8<bool> any_bits_set(simd8<uint8_t> bits) const {
+    return vtstq_u8(*this, bits);
+  }
+  is_utf8_really_inline bool is_ascii() const {
+    return this->max_val() < 0b10000000u;
+  }
+
+  is_utf8_really_inline bool any_bits_set_anywhere() const {
+    return this->max_val() != 0;
+  }
+  is_utf8_really_inline bool any_bits_set_anywhere(simd8<uint8_t> bits) const {
+    return (*this & bits).any_bits_set_anywhere();
+  }
+  template <int N> is_utf8_really_inline simd8<uint8_t> shr() const {
+    return vshrq_n_u8(*this, N);
+  }
+  template <int N> is_utf8_really_inline simd8<uint8_t> shl() const {
+    return vshlq_n_u8(*this, N);
+  }
+
+  // Perform a lookup assuming the value is between 0 and 16 (undefined behavior
+  // for out of range values)
+  template <typename L>
+  is_utf8_really_inline simd8<L> lookup_16(simd8<L> lookup_table) const {
+    return lookup_table.apply_lookup_16_to(*this);
+  }
+
+  template <typename L>
+  is_utf8_really_inline simd8<L>
+  lookup_16(L replace0, L replace1, L replace2, L replace3, L replace4,
+            L replace5, L replace6, L replace7, L replace8, L replace9,
+            L replace10, L replace11, L replace12, L replace13, L replace14,
+            L replace15) const {
+    return lookup_16(simd8<L>::repeat_16(
+        replace0, replace1, replace2, replace3, replace4, replace5, replace6,
+        replace7, replace8, replace9, replace10, replace11, replace12,
+        replace13, replace14, replace15));
+  }
+
+  template <typename T>
+  is_utf8_really_inline simd8<uint8_t>
+  apply_lookup_16_to(const simd8<T> original) const {
+    return vqtbl1q_u8(*this, simd8<uint8_t>(original));
+  }
+};
+
+// Signed bytes
+template <> struct simd8<int8_t> {
+  int8x16_t value;
+
+  static is_utf8_really_inline simd8<int8_t> splat(int8_t _value) {
+    return vmovq_n_s8(_value);
+  }
+  static is_utf8_really_inline simd8<int8_t> zero() { return vdupq_n_s8(0); }
+  static is_utf8_really_inline simd8<int8_t> load(const int8_t values[16]) {
+    return vld1q_s8(values);
+  }
+  template <endianness big_endian>
+  is_utf8_really_inline void store_ascii_as_utf16(char16_t *p) const {
+    uint16x8_t first = vmovl_u8(vget_low_u8(vreinterpretq_u8_s8(this->value)));
+    uint16x8_t second = vmovl_high_u8(vreinterpretq_u8_s8(this->value));
+    if (big_endian) {
+#ifdef IS_UTF8_REGULAR_VISUAL_STUDIO
+      const uint8x16_t swap =
+          make_uint8x16_t(1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14);
+#else
+      const uint8x16_t swap = {1, 0, 3,  2,  5,  4,  7,  6,
+                               9, 8, 11, 10, 13, 12, 15, 14};
+#endif
+      first =
+          vreinterpretq_u16_u8(vqtbl1q_u8(vreinterpretq_u8_u16(first), swap));
+      second =
+          vreinterpretq_u16_u8(vqtbl1q_u8(vreinterpretq_u8_u16(second), swap));
+    }
+    vst1q_u16(reinterpret_cast<uint16_t *>(p), first);
+    vst1q_u16(reinterpret_cast<uint16_t *>(p + 8), second);
+  }
+  is_utf8_really_inline void store_ascii_as_utf32(char32_t *p) const {
+    vst1q_u32(reinterpret_cast<uint32_t *>(p),
+              vmovl_u16(vget_low_u16(
+                  vmovl_u8(vget_low_u8(vreinterpretq_u8_s8(this->value))))));
+    vst1q_u32(reinterpret_cast<uint32_t *>(p + 4),
+              vmovl_high_u16(
+                  vmovl_u8(vget_low_u8(vreinterpretq_u8_s8(this->value)))));
+    vst1q_u32(reinterpret_cast<uint32_t *>(p + 8),
+              vmovl_u16(vget_low_u16(
+                  vmovl_high_u8(vreinterpretq_u8_s8(this->value)))));
+    vst1q_u32(reinterpret_cast<uint32_t *>(p + 12),
+              vmovl_high_u16(vmovl_high_u8(vreinterpretq_u8_s8(this->value))));
+  }
+  // Conversion from/to SIMD register
+  is_utf8_really_inline simd8(const int8x16_t _value) : value{_value} {}
+  is_utf8_really_inline operator const int8x16_t &() const {
+    return this->value;
+  }
+  is_utf8_really_inline operator const uint8x16_t() const {
+    return vreinterpretq_u8_s8(this->value);
+  }
+  is_utf8_really_inline operator int8x16_t &() { return this->value; }
+
+  // Zero constructor
+  is_utf8_really_inline simd8() : simd8(zero()) {}
+  // Splat constructor
+  is_utf8_really_inline simd8(int8_t _value) : simd8(splat(_value)) {}
+  // Array constructor
+  is_utf8_really_inline simd8(const int8_t *values) : simd8(load(values)) {}
+  // Member-by-member initialization
+#ifdef IS_UTF8_REGULAR_VISUAL_STUDIO
+  is_utf8_really_inline simd8(int8_t v0, int8_t v1, int8_t v2, int8_t v3,
+                              int8_t v4, int8_t v5, int8_t v6, int8_t v7,
+                              int8_t v8, int8_t v9, int8_t v10, int8_t v11,
+                              int8_t v12, int8_t v13, int8_t v14, int8_t v15)
+      : simd8(make_int8x16_t(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11,
+                             v12, v13, v14, v15)) {}
+#else
+  is_utf8_really_inline simd8(int8_t v0, int8_t v1, int8_t v2, int8_t v3,
+                              int8_t v4, int8_t v5, int8_t v6, int8_t v7,
+                              int8_t v8, int8_t v9, int8_t v10, int8_t v11,
+                              int8_t v12, int8_t v13, int8_t v14, int8_t v15)
+      : simd8(int8x16_t{v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12,
+                        v13, v14, v15}) {}
+#endif
+  // Repeat 16 values as many times as necessary (usually for lookup tables)
+  is_utf8_really_inline static simd8<int8_t>
+  repeat_16(int8_t v0, int8_t v1, int8_t v2, int8_t v3, int8_t v4, int8_t v5,
+            int8_t v6, int8_t v7, int8_t v8, int8_t v9, int8_t v10, int8_t v11,
+            int8_t v12, int8_t v13, int8_t v14, int8_t v15) {
+    return simd8<int8_t>(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12,
+                         v13, v14, v15);
+  }
+
+  // Store to array
+  is_utf8_really_inline void store(int8_t dst[16]) const {
+    return vst1q_s8(dst, value);
+  }
+  // Explicit conversion to/from unsigned
+  //
+  // Under Visual Studio/ARM64 uint8x16_t and int8x16_t are apparently the same
+  // type. In theory, we could check this occurrence with std::same_as and
+  // std::enabled_if but it is C++14 and relatively ugly and hard to read.
+#ifndef IS_UTF8_REGULAR_VISUAL_STUDIO
+  is_utf8_really_inline explicit simd8(const uint8x16_t other)
+      : simd8(vreinterpretq_s8_u8(other)) {}
+#endif
+  is_utf8_really_inline operator simd8<uint8_t>() const {
+    return vreinterpretq_u8_s8(this->value);
+  }
+
+  is_utf8_really_inline simd8<int8_t>
+  operator|(const simd8<int8_t> other) const {
+    return vorrq_s8(value, other.value);
+  }
+  is_utf8_really_inline simd8<int8_t>
+  operator&(const simd8<int8_t> other) const {
+    return vandq_s8(value, other.value);
+  }
+  is_utf8_really_inline simd8<int8_t>
+  operator^(const simd8<int8_t> other) const {
+    return veorq_s8(value, other.value);
+  }
+  is_utf8_really_inline simd8<int8_t>
+  bit_andnot(const simd8<int8_t> other) const {
+    return vbicq_s8(value, other.value);
+  }
+
+  // Math
+  is_utf8_really_inline simd8<int8_t>
+  operator+(const simd8<int8_t> other) const {
+    return vaddq_s8(value, other.value);
+  }
+  is_utf8_really_inline simd8<int8_t>
+  operator-(const simd8<int8_t> other) const {
+    return vsubq_s8(value, other.value);
+  }
+  is_utf8_really_inline simd8<int8_t> &operator+=(const simd8<int8_t> other) {
+    *this = *this + other;
+    return *this;
+  }
+  is_utf8_really_inline simd8<int8_t> &operator-=(const simd8<int8_t> other) {
+    *this = *this - other;
+    return *this;
+  }
+
+  is_utf8_really_inline int8_t max_val() const { return vmaxvq_s8(value); }
+  is_utf8_really_inline int8_t min_val() const { return vminvq_s8(value); }
+  is_utf8_really_inline bool is_ascii() const { return this->min_val() >= 0; }
+
+  // Order-sensitive comparisons
+  is_utf8_really_inline simd8<int8_t> max_val(const simd8<int8_t> other) const {
+    return vmaxq_s8(value, other.value);
+  }
+  is_utf8_really_inline simd8<int8_t> min_val(const simd8<int8_t> other) const {
+    return vminq_s8(value, other.value);
+  }
+  is_utf8_really_inline simd8<bool> operator>(const simd8<int8_t> other) const {
+    return vcgtq_s8(value, other.value);
+  }
+  is_utf8_really_inline simd8<bool> operator<(const simd8<int8_t> other) const {
+    return vcltq_s8(value, other.value);
+  }
+  is_utf8_really_inline simd8<bool>
+  operator==(const simd8<int8_t> other) const {
+    return vceqq_s8(value, other.value);
+  }
+
+  template <int N = 1>
+  is_utf8_really_inline simd8<int8_t>
+  prev(const simd8<int8_t> prev_chunk) const {
+    return vextq_s8(prev_chunk, *this, 16 - N);
+  }
+
+  // Perform a lookup assuming no value is larger than 16
+  template <typename L>
+  is_utf8_really_inline simd8<L> lookup_16(simd8<L> lookup_table) const {
+    return lookup_table.apply_lookup_16_to(*this);
+  }
+  template <typename L>
+  is_utf8_really_inline simd8<L>
+  lookup_16(L replace0, L replace1, L replace2, L replace3, L replace4,
+            L replace5, L replace6, L replace7, L replace8, L replace9,
+            L replace10, L replace11, L replace12, L replace13, L replace14,
+            L replace15) const {
+    return lookup_16(simd8<L>::repeat_16(
+        replace0, replace1, replace2, replace3, replace4, replace5, replace6,
+        replace7, replace8, replace9, replace10, replace11, replace12,
+        replace13, replace14, replace15));
+  }
+
+  template <typename T>
+  is_utf8_really_inline simd8<int8_t>
+  apply_lookup_16_to(const simd8<T> original) {
+    return vqtbl1q_s8(*this, simd8<uint8_t>(original));
+  }
+};
+
+template <typename T> struct simd8x64 {
+  static constexpr int NUM_CHUNKS = 64 / sizeof(simd8<T>);
+  static_assert(NUM_CHUNKS == 4,
+                "ARM kernel should use four registers per 64-byte block.");
+  simd8<T> chunks[NUM_CHUNKS];
+
+  simd8x64(const simd8x64<T> &o) = delete; // no copy allowed
+  simd8x64<T> &
+  operator=(const simd8<T> other) = delete; // no assignment allowed
+  simd8x64() = delete;                      // no default constructor allowed
+
+  is_utf8_really_inline simd8x64(const simd8<T> chunk0, const simd8<T> chunk1,
+                                 const simd8<T> chunk2, const simd8<T> chunk3)
+      : chunks{chunk0, chunk1, chunk2, chunk3} {}
+  is_utf8_really_inline simd8x64(const T *ptr)
+      : chunks{simd8<T>::load(ptr),
+               simd8<T>::load(ptr + sizeof(simd8<T>) / sizeof(T)),
+               simd8<T>::load(ptr + 2 * sizeof(simd8<T>) / sizeof(T)),
+               simd8<T>::load(ptr + 3 * sizeof(simd8<T>) / sizeof(T))} {}
+
+  is_utf8_really_inline void store(T *ptr) const {
+    this->chunks[0].store(ptr + sizeof(simd8<T>) * 0 / sizeof(T));
+    this->chunks[1].store(ptr + sizeof(simd8<T>) * 1 / sizeof(T));
+    this->chunks[2].store(ptr + sizeof(simd8<T>) * 2 / sizeof(T));
+    this->chunks[3].store(ptr + sizeof(simd8<T>) * 3 / sizeof(T));
+  }
+
+  is_utf8_really_inline simd8x64<T> &operator|=(const simd8x64<T> &other) {
+    this->chunks[0] |= other.chunks[0];
+    this->chunks[1] |= other.chunks[1];
+    this->chunks[2] |= other.chunks[2];
+    this->chunks[3] |= other.chunks[3];
+    return *this;
+  }
+
+  is_utf8_really_inline simd8<T> reduce_or() const {
+    return (this->chunks[0] | this->chunks[1]) |
+           (this->chunks[2] | this->chunks[3]);
+  }
+
+  is_utf8_really_inline bool is_ascii() const { return reduce_or().is_ascii(); }
+
+  template <endianness endian>
+  is_utf8_really_inline void store_ascii_as_utf16(char16_t *ptr) const {
+    this->chunks[0].template store_ascii_as_utf16<endian>(ptr +
+                                                          sizeof(simd8<T>) * 0);
+    this->chunks[1].template store_ascii_as_utf16<endian>(ptr +
+                                                          sizeof(simd8<T>) * 1);
+    this->chunks[2].template store_ascii_as_utf16<endian>(ptr +
+                                                          sizeof(simd8<T>) * 2);
+    this->chunks[3].template store_ascii_as_utf16<endian>(ptr +
+                                                          sizeof(simd8<T>) * 3);
+  }
+
+  is_utf8_really_inline void store_ascii_as_utf32(char32_t *ptr) const {
+    this->chunks[0].store_ascii_as_utf32(ptr + sizeof(simd8<T>) * 0);
+    this->chunks[1].store_ascii_as_utf32(ptr + sizeof(simd8<T>) * 1);
+    this->chunks[2].store_ascii_as_utf32(ptr + sizeof(simd8<T>) * 2);
+    this->chunks[3].store_ascii_as_utf32(ptr + sizeof(simd8<T>) * 3);
+  }
+
+  is_utf8_really_inline uint64_t to_bitmask() const {
+#ifdef IS_UTF8_REGULAR_VISUAL_STUDIO
+    const uint8x16_t bit_mask =
+        make_uint8x16_t(0x01, 0x02, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80, 0x01,
+                        0x02, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80);
+#else
+    const uint8x16_t bit_mask = {0x01, 0x02, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80,
+                                 0x01, 0x02, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80};
+#endif
+    // Add each of the elements next to each other, successively, to stuff each
+    // 8 byte mask into one.
+    uint8x16_t sum0 =
+        vpaddq_u8(vandq_u8(uint8x16_t(this->chunks[0]), bit_mask),
+                  vandq_u8(uint8x16_t(this->chunks[1]), bit_mask));
+    uint8x16_t sum1 =
+        vpaddq_u8(vandq_u8(uint8x16_t(this->chunks[2]), bit_mask),
+                  vandq_u8(uint8x16_t(this->chunks[3]), bit_mask));
+    sum0 = vpaddq_u8(sum0, sum1);
+    sum0 = vpaddq_u8(sum0, sum0);
+    return vgetq_lane_u64(vreinterpretq_u64_u8(sum0), 0);
+  }
+
+  is_utf8_really_inline uint64_t eq(const T m) const {
+    const simd8<T> mask = simd8<T>::splat(m);
+    return simd8x64<bool>(this->chunks[0] == mask, this->chunks[1] == mask,
+                          this->chunks[2] == mask, this->chunks[3] == mask)
+        .to_bitmask();
+  }
+
+  is_utf8_really_inline uint64_t lteq(const T m) const {
+    const simd8<T> mask = simd8<T>::splat(m);
+    return simd8x64<bool>(this->chunks[0] <= mask, this->chunks[1] <= mask,
+                          this->chunks[2] <= mask, this->chunks[3] <= mask)
+        .to_bitmask();
+  }
+
+  is_utf8_really_inline uint64_t in_range(const T low, const T high) const {
+    const simd8<T> mask_low = simd8<T>::splat(low);
+    const simd8<T> mask_high = simd8<T>::splat(high);
+
+    return simd8x64<bool>(
+               (this->chunks[0] <= mask_high) & (this->chunks[0] >= mask_low),
+               (this->chunks[1] <= mask_high) & (this->chunks[1] >= mask_low),
+               (this->chunks[2] <= mask_high) & (this->chunks[2] >= mask_low),
+               (this->chunks[3] <= mask_high) & (this->chunks[3] >= mask_low))
+        .to_bitmask();
+  }
+  is_utf8_really_inline uint64_t not_in_range(const T low, const T high) const {
+    const simd8<T> mask_low = simd8<T>::splat(low);
+    const simd8<T> mask_high = simd8<T>::splat(high);
+    return simd8x64<bool>(
+               (this->chunks[0] > mask_high) | (this->chunks[0] < mask_low),
+               (this->chunks[1] > mask_high) | (this->chunks[1] < mask_low),
+               (this->chunks[2] > mask_high) | (this->chunks[2] < mask_low),
+               (this->chunks[3] > mask_high) | (this->chunks[3] < mask_low))
+        .to_bitmask();
+  }
+  is_utf8_really_inline uint64_t lt(const T m) const {
+    const simd8<T> mask = simd8<T>::splat(m);
+    return simd8x64<bool>(this->chunks[0] < mask, this->chunks[1] < mask,
+                          this->chunks[2] < mask, this->chunks[3] < mask)
+        .to_bitmask();
+  }
+  is_utf8_really_inline uint64_t gt(const T m) const {
+    const simd8<T> mask = simd8<T>::splat(m);
+    return simd8x64<bool>(this->chunks[0] > mask, this->chunks[1] > mask,
+                          this->chunks[2] > mask, this->chunks[3] > mask)
+        .to_bitmask();
+  }
+  is_utf8_really_inline uint64_t gteq(const T m) const {
+    const simd8<T> mask = simd8<T>::splat(m);
+    return simd8x64<bool>(this->chunks[0] >= mask, this->chunks[1] >= mask,
+                          this->chunks[2] >= mask, this->chunks[3] >= mask)
+        .to_bitmask();
+  }
+  is_utf8_really_inline uint64_t gteq_unsigned(const uint8_t m) const {
+    const simd8<uint8_t> mask = simd8<uint8_t>::splat(m);
+    return simd8x64<bool>(simd8<uint8_t>(uint8x16_t(this->chunks[0])) >= mask,
+                          simd8<uint8_t>(uint8x16_t(this->chunks[1])) >= mask,
+                          simd8<uint8_t>(uint8x16_t(this->chunks[2])) >= mask,
+                          simd8<uint8_t>(uint8x16_t(this->chunks[3])) >= mask)
+        .to_bitmask();
+  }
+}; // struct simd8x64<T>
+
+template <typename T> struct simd16;
+
+template <typename T, typename Mask = simd16<bool>> struct base_u16 {
+  uint16x8_t value;
+  static const int SIZE = sizeof(value);
+
+  // Conversion from/to SIMD register
+  is_utf8_really_inline base_u16() = default;
+  is_utf8_really_inline base_u16(const uint16x8_t _value) : value(_value) {}
+  is_utf8_really_inline operator const uint16x8_t &() const {
+    return this->value;
+  }
+  is_utf8_really_inline operator uint16x8_t &() { return this->value; }
+  // Bit operations
+  is_utf8_really_inline simd16<T> operator|(const simd16<T> other) const {
+    return vorrq_u16(*this, other);
+  }
+  is_utf8_really_inline simd16<T> operator&(const simd16<T> other) const {
+    return vandq_u16(*this, other);
+  }
+  is_utf8_really_inline simd16<T> operator^(const simd16<T> other) const {
+    return veorq_u16(*this, other);
+  }
+  is_utf8_really_inline simd16<T> bit_andnot(const simd16<T> other) const {
+    return vbicq_u16(*this, other);
+  }
+  is_utf8_really_inline simd16<T> operator~() const { return *this ^ 0xFFu; }
+  is_utf8_really_inline simd16<T> &operator|=(const simd16<T> other) {
+    auto this_cast = static_cast<simd16<T> *>(this);
+    *this_cast = *this_cast | other;
+    return *this_cast;
+  }
+  is_utf8_really_inline simd16<T> &operator&=(const simd16<T> other) {
+    auto this_cast = static_cast<simd16<T> *>(this);
+    *this_cast = *this_cast & other;
+    return *this_cast;
+  }
+  is_utf8_really_inline simd16<T> &operator^=(const simd16<T> other) {
+    auto this_cast = static_cast<simd16<T> *>(this);
+    *this_cast = *this_cast ^ other;
+    return *this_cast;
+  }
+
+  is_utf8_really_inline Mask operator==(const simd16<T> other) const {
+    return vceqq_u16(*this, other);
+  }
+
+  template <int N = 1>
+  is_utf8_really_inline simd16<T> prev(const simd16<T> prev_chunk) const {
+    return vextq_u18(prev_chunk, *this, 8 - N);
+  }
+};
+
+template <typename T, typename Mask = simd16<bool>>
+struct base16 : base_u16<T> {
+  typedef uint16_t bitmask_t;
+  typedef uint32_t bitmask2_t;
+
+  is_utf8_really_inline base16() : base_u16<T>() {}
+  is_utf8_really_inline base16(const uint16x8_t _value) : base_u16<T>(_value) {}
+  template <typename Pointer>
+  is_utf8_really_inline base16(const Pointer *ptr) : base16(vld1q_u16(ptr)) {}
+
+  is_utf8_really_inline Mask operator==(const simd16<T> other) const {
+    return vceqq_u16(*this, other);
+  }
+
+  static const int SIZE = sizeof(base_u16<T>::value);
+
+  template <int N = 1>
+  is_utf8_really_inline simd16<T> prev(const simd16<T> prev_chunk) const {
+    return vextq_u18(prev_chunk, *this, 8 - N);
+  }
+};
+
+// SIMD byte mask type (returned by things like eq and gt)
+template <> struct simd16<bool> : base16<bool> {
+  static is_utf8_really_inline simd16<bool> splat(bool _value) {
+    return vmovq_n_u16(uint16_t(-(!!_value)));
+  }
+
+  is_utf8_really_inline simd16<bool>() : base16() {}
+  is_utf8_really_inline simd16<bool>(const uint16x8_t _value)
+      : base16<bool>(_value) {}
+  // Splat constructor
+  is_utf8_really_inline simd16<bool>(bool _value)
+      : base16<bool>(splat(_value)) {}
+};
+
+template <typename T> struct base16_numeric : base16<T> {
+  static is_utf8_really_inline simd16<T> splat(T _value) {
+    return vmovq_n_u16(_value);
+  }
+  static is_utf8_really_inline simd16<T> zero() { return vdupq_n_u16(0); }
+  static is_utf8_really_inline simd16<T> load(const T values[8]) {
+    return vld1q_u16(reinterpret_cast<const uint16_t *>(values));
+  }
+
+  is_utf8_really_inline base16_numeric() : base16<T>() {}
+  is_utf8_really_inline base16_numeric(const uint16x8_t _value)
+      : base16<T>(_value) {}
+
+  // Store to array
+  is_utf8_really_inline void store(T dst[8]) const {
+    return vst1q_u16(dst, *this);
+  }
+
+  // Override to distinguish from bool version
+  is_utf8_really_inline simd16<T> operator~() const { return *this ^ 0xFFu; }
+
+  // Addition/subtraction are the same for signed and unsigned
+  is_utf8_really_inline simd16<T> operator+(const simd16<T> other) const {
+    return vaddq_u8(*this, other);
+  }
+  is_utf8_really_inline simd16<T> operator-(const simd16<T> other) const {
+    return vsubq_u8(*this, other);
+  }
+  is_utf8_really_inline simd16<T> &operator+=(const simd16<T> other) {
+    *this = *this + other;
+    return *static_cast<simd16<T> *>(this);
+  }
+  is_utf8_really_inline simd16<T> &operator-=(const simd16<T> other) {
+    *this = *this - other;
+    return *static_cast<simd16<T> *>(this);
+  }
+};
+
+// Signed words
+template <> struct simd16<int16_t> : base16_numeric<int16_t> {
+  is_utf8_really_inline simd16() : base16_numeric<int16_t>() {}
+#ifndef IS_UTF8_REGULAR_VISUAL_STUDIO
+  is_utf8_really_inline simd16(const uint16x8_t _value)
+      : base16_numeric<int16_t>(_value) {}
+#endif
+  is_utf8_really_inline simd16(const int16x8_t _value)
+      : base16_numeric<int16_t>(vreinterpretq_u16_s16(_value)) {}
+
+  // Splat constructor
+  is_utf8_really_inline simd16(int16_t _value) : simd16(splat(_value)) {}
+  // Array constructor
+  is_utf8_really_inline simd16(const int16_t *values) : simd16(load(values)) {}
+  is_utf8_really_inline simd16(const char16_t *values)
+      : simd16(load(reinterpret_cast<const int16_t *>(values))) {}
+  is_utf8_really_inline operator simd16<uint16_t>() const;
+  is_utf8_really_inline operator const uint16x8_t &() const {
+    return this->value;
+  }
+  is_utf8_really_inline operator const int16x8_t() const {
+    return vreinterpretq_s16_u16(this->value);
+  }
+
+  is_utf8_really_inline int16_t max_val() const {
+    return vmaxvq_s16(vreinterpretq_s16_u16(this->value));
+  }
+  is_utf8_really_inline int16_t min_val() const {
+    return vminvq_s16(vreinterpretq_s16_u16(this->value));
+  }
+  // Order-sensitive comparisons
+  is_utf8_really_inline simd16<int16_t>
+  max_val(const simd16<int16_t> other) const {
+    return vmaxq_s16(vreinterpretq_s16_u16(this->value),
+                     vreinterpretq_s16_u16(other.value));
+  }
+  is_utf8_really_inline simd16<int16_t>
+  min_val(const simd16<int16_t> other) const {
+    return vmaxq_s16(vreinterpretq_s16_u16(this->value),
+                     vreinterpretq_s16_u16(other.value));
+  }
+  is_utf8_really_inline simd16<bool>
+  operator>(const simd16<int16_t> other) const {
+    return vcgtq_s16(vreinterpretq_s16_u16(this->value),
+                     vreinterpretq_s16_u16(other.value));
+  }
+  is_utf8_really_inline simd16<bool>
+  operator<(const simd16<int16_t> other) const {
+    return vcltq_s16(vreinterpretq_s16_u16(this->value),
+                     vreinterpretq_s16_u16(other.value));
+  }
+};
+
+// Unsigned words
+template <> struct simd16<uint16_t> : base16_numeric<uint16_t> {
+  is_utf8_really_inline simd16() : base16_numeric<uint16_t>() {}
+  is_utf8_really_inline simd16(const uint16x8_t _value)
+      : base16_numeric<uint16_t>(_value) {}
+
+  // Splat constructor
+  is_utf8_really_inline simd16(uint16_t _value) : simd16(splat(_value)) {}
+  // Array constructor
+  is_utf8_really_inline simd16(const uint16_t *values) : simd16(load(values)) {}
+  is_utf8_really_inline simd16(const char16_t *values)
+      : simd16(load(reinterpret_cast<const uint16_t *>(values))) {}
+
+  is_utf8_really_inline int16_t max_val() const { return vmaxvq_u16(*this); }
+  is_utf8_really_inline int16_t min_val() const { return vminvq_u16(*this); }
+  // Saturated math
+  is_utf8_really_inline simd16<uint16_t>
+  saturating_add(const simd16<uint16_t> other) const {
+    return vqaddq_u16(*this, other);
+  }
+  is_utf8_really_inline simd16<uint16_t>
+  saturating_sub(const simd16<uint16_t> other) const {
+    return vqsubq_u16(*this, other);
+  }
+
+  // Order-specific operations
+  is_utf8_really_inline simd16<uint16_t>
+  max_val(const simd16<uint16_t> other) const {
+    return vmaxq_u16(*this, other);
+  }
+  is_utf8_really_inline simd16<uint16_t>
+  min_val(const simd16<uint16_t> other) const {
+    return vminq_u16(*this, other);
+  }
+  // Same as >, but only guarantees true is nonzero (< guarantees true = -1)
+  is_utf8_really_inline simd16<uint16_t>
+  gt_bits(const simd16<uint16_t> other) const {
+    return this->saturating_sub(other);
+  }
+  // Same as <, but only guarantees true is nonzero (< guarantees true = -1)
+  is_utf8_really_inline simd16<uint16_t>
+  lt_bits(const simd16<uint16_t> other) const {
+    return other.saturating_sub(*this);
+  }
+  is_utf8_really_inline simd16<bool>
+  operator<=(const simd16<uint16_t> other) const {
+    return vcleq_u16(*this, other);
+  }
+  is_utf8_really_inline simd16<bool>
+  operator>=(const simd16<uint16_t> other) const {
+    return vcgeq_u16(*this, other);
+  }
+  is_utf8_really_inline simd16<bool>
+  operator>(const simd16<uint16_t> other) const {
+    return vcgtq_u16(*this, other);
+  }
+  is_utf8_really_inline simd16<bool>
+  operator<(const simd16<uint16_t> other) const {
+    return vcltq_u16(*this, other);
+  }
+
+  // Bit-specific operations
+  is_utf8_really_inline simd16<bool> bits_not_set() const {
+    return *this == uint16_t(0);
+  }
+  template <int N> is_utf8_really_inline simd16<uint16_t> shr() const {
+    return simd16<uint16_t>(vshrq_n_u16(*this, N));
+  }
+  template <int N> is_utf8_really_inline simd16<uint16_t> shl() const {
+    return simd16<uint16_t>(vshlq_n_u16(*this, N));
+  }
+
+  // logical operations
+  is_utf8_really_inline simd16<uint16_t>
+  operator|(const simd16<uint16_t> other) const {
+    return vorrq_u16(*this, other);
+  }
+  is_utf8_really_inline simd16<uint16_t>
+  operator&(const simd16<uint16_t> other) const {
+    return vandq_u16(*this, other);
+  }
+  is_utf8_really_inline simd16<uint16_t>
+  operator^(const simd16<uint16_t> other) const {
+    return veorq_u16(*this, other);
+  }
+
+  // Pack with the unsigned saturation  two uint16_t words into single uint8_t
+  // vector
+  static is_utf8_really_inline simd8<uint8_t> pack(const simd16<uint16_t> &v0,
+                                                   const simd16<uint16_t> &v1) {
+    return vqmovn_high_u16(vqmovn_u16(v0), v1);
+  }
+
+  // Change the endianness
+  is_utf8_really_inline simd16<uint16_t> swap_bytes() const {
+#ifdef IS_UTF8_REGULAR_VISUAL_STUDIO
+    const uint8x16_t swap =
+        make_uint8x16_t(1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14);
+#else
+    const uint8x16_t swap = {1, 0, 3,  2,  5,  4,  7,  6,
+                             9, 8, 11, 10, 13, 12, 15, 14};
+#endif
+    return vreinterpretq_u16_u8(vqtbl1q_u8(vreinterpretq_u8_u16(*this), swap));
+  }
+};
+is_utf8_really_inline simd16<int16_t>::operator simd16<uint16_t>() const {
+  return this->value;
+}
+
+template <typename T> struct simd16x32 {
+  static constexpr int NUM_CHUNKS = 64 / sizeof(simd16<T>);
+  static_assert(NUM_CHUNKS == 4,
+                "ARM kernel should use four registers per 64-byte block.");
+  simd16<T> chunks[NUM_CHUNKS];
+
+  simd16x32(const simd16x32<T> &o) = delete; // no copy allowed
+  simd16x32<T> &
+  operator=(const simd16<T> other) = delete; // no assignment allowed
+  simd16x32() = delete;                      // no default constructor allowed
+
+  is_utf8_really_inline
+  simd16x32(const simd16<T> chunk0, const simd16<T> chunk1,
+            const simd16<T> chunk2, const simd16<T> chunk3)
+      : chunks{chunk0, chunk1, chunk2, chunk3} {}
+  is_utf8_really_inline simd16x32(const T *ptr)
+      : chunks{simd16<T>::load(ptr),
+               simd16<T>::load(ptr + sizeof(simd16<T>) / sizeof(T)),
+               simd16<T>::load(ptr + 2 * sizeof(simd16<T>) / sizeof(T)),
+               simd16<T>::load(ptr + 3 * sizeof(simd16<T>) / sizeof(T))} {}
+
+  is_utf8_really_inline void store(T *ptr) const {
+    this->chunks[0].store(ptr + sizeof(simd16<T>) * 0 / sizeof(T));
+    this->chunks[1].store(ptr + sizeof(simd16<T>) * 1 / sizeof(T));
+    this->chunks[2].store(ptr + sizeof(simd16<T>) * 2 / sizeof(T));
+    this->chunks[3].store(ptr + sizeof(simd16<T>) * 3 / sizeof(T));
+  }
+
+  is_utf8_really_inline simd16<T> reduce_or() const {
+    return (this->chunks[0] | this->chunks[1]) |
+           (this->chunks[2] | this->chunks[3]);
+  }
+
+  is_utf8_really_inline bool is_ascii() const { return reduce_or().is_ascii(); }
+
+  is_utf8_really_inline void store_ascii_as_utf16(char16_t *ptr) const {
+    this->chunks[0].store_ascii_as_utf16(ptr + sizeof(simd16<T>) * 0);
+    this->chunks[1].store_ascii_as_utf16(ptr + sizeof(simd16<T>) * 1);
+    this->chunks[2].store_ascii_as_utf16(ptr + sizeof(simd16<T>) * 2);
+    this->chunks[3].store_ascii_as_utf16(ptr + sizeof(simd16<T>) * 3);
+  }
+
+  is_utf8_really_inline uint64_t to_bitmask() const {
+#ifdef IS_UTF8_REGULAR_VISUAL_STUDIO
+    const uint8x16_t bit_mask =
+        make_uint8x16_t(0x01, 0x02, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80, 0x01,
+                        0x02, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80);
+#else
+    const uint8x16_t bit_mask = {0x01, 0x02, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80,
+                                 0x01, 0x02, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80};
+#endif
+    // Add each of the elements next to each other, successively, to stuff each
+    // 8 byte mask into one.
+    uint8x16_t sum0 = vpaddq_u8(
+        vreinterpretq_u8_u16(this->chunks[0] & vreinterpretq_u16_u8(bit_mask)),
+        vreinterpretq_u8_u16(this->chunks[1] & vreinterpretq_u16_u8(bit_mask)));
+    uint8x16_t sum1 = vpaddq_u8(
+        vreinterpretq_u8_u16(this->chunks[2] & vreinterpretq_u16_u8(bit_mask)),
+        vreinterpretq_u8_u16(this->chunks[3] & vreinterpretq_u16_u8(bit_mask)));
+    sum0 = vpaddq_u8(sum0, sum1);
+    sum0 = vpaddq_u8(sum0, sum0);
+    return vgetq_lane_u64(vreinterpretq_u64_u8(sum0), 0);
+  }
+
+  is_utf8_really_inline void swap_bytes() {
+    this->chunks[0] = this->chunks[0].swap_bytes();
+    this->chunks[1] = this->chunks[1].swap_bytes();
+    this->chunks[2] = this->chunks[2].swap_bytes();
+    this->chunks[3] = this->chunks[3].swap_bytes();
+  }
+
+  is_utf8_really_inline uint64_t eq(const T m) const {
+    const simd16<T> mask = simd16<T>::splat(m);
+    return simd16x32<bool>(this->chunks[0] == mask, this->chunks[1] == mask,
+                           this->chunks[2] == mask, this->chunks[3] == mask)
+        .to_bitmask();
+  }
+
+  is_utf8_really_inline uint64_t lteq(const T m) const {
+    const simd16<T> mask = simd16<T>::splat(m);
+    return simd16x32<bool>(this->chunks[0] <= mask, this->chunks[1] <= mask,
+                           this->chunks[2] <= mask, this->chunks[3] <= mask)
+        .to_bitmask();
+  }
+
+  is_utf8_really_inline uint64_t in_range(const T low, const T high) const {
+    const simd16<T> mask_low = simd16<T>::splat(low);
+    const simd16<T> mask_high = simd16<T>::splat(high);
+
+    return simd16x32<bool>(
+               (this->chunks[0] <= mask_high) & (this->chunks[0] >= mask_low),
+               (this->chunks[1] <= mask_high) & (this->chunks[1] >= mask_low),
+               (this->chunks[2] <= mask_high) & (this->chunks[2] >= mask_low),
+               (this->chunks[3] <= mask_high) & (this->chunks[3] >= mask_low))
+        .to_bitmask();
+  }
+  is_utf8_really_inline uint64_t not_in_range(const T low, const T high) const {
+    const simd16<T> mask_low = simd16<T>::splat(low);
+    const simd16<T> mask_high = simd16<T>::splat(high);
+    return simd16x32<bool>(
+               (this->chunks[0] > mask_high) | (this->chunks[0] < mask_low),
+               (this->chunks[1] > mask_high) | (this->chunks[1] < mask_low),
+               (this->chunks[2] > mask_high) | (this->chunks[2] < mask_low),
+               (this->chunks[3] > mask_high) | (this->chunks[3] < mask_low))
+        .to_bitmask();
+  }
+  is_utf8_really_inline uint64_t lt(const T m) const {
+    const simd16<T> mask = simd16<T>::splat(m);
+    return simd16x32<bool>(this->chunks[0] < mask, this->chunks[1] < mask,
+                           this->chunks[2] < mask, this->chunks[3] < mask)
+        .to_bitmask();
+  }
+
+}; // struct simd16x32<T>
+template <>
+is_utf8_really_inline uint64_t simd16x32<uint16_t>::not_in_range(
+    const uint16_t low, const uint16_t high) const {
+  const simd16<uint16_t> mask_low = simd16<uint16_t>::splat(low);
+  const simd16<uint16_t> mask_high = simd16<uint16_t>::splat(high);
+  simd16x32<uint16_t> x(simd16<uint16_t>((this->chunks[0] > mask_high) |
+                                         (this->chunks[0] < mask_low)),
+                        simd16<uint16_t>((this->chunks[1] > mask_high) |
+                                         (this->chunks[1] < mask_low)),
+                        simd16<uint16_t>((this->chunks[2] > mask_high) |
+                                         (this->chunks[2] < mask_low)),
+                        simd16<uint16_t>((this->chunks[3] > mask_high) |
+                                         (this->chunks[3] < mask_low)));
+  return x.to_bitmask();
+}
+
+} // namespace simd
+} // unnamed namespace
+} // namespace arm64
+} // namespace is_utf8_internals
+
+#endif // IS_UTF8_ARM64_SIMD_H
+
+#endif // IS_UTF8_IMPLEMENTATION_ARM64
+
+#endif // IS_UTF8_ARM64_H
+
+#ifndef IS_UTF8_ICELAKE_H
+#define IS_UTF8_ICELAKE_H
+
+#ifdef __has_include
+// How do we detect that a compiler supports vbmi2?
+// For sure if the following header is found, we are ok?
+#if __has_include(<avx512vbmi2intrin.h>)
+#define IS_UTF8_COMPILER_SUPPORTS_VBMI2 1
+#endif
+#endif
+
+#ifdef _MSC_VER
+#if _MSC_VER >= 1920
+// Visual Studio 2019 and up support VBMI2 under x64 even if the header
+// avx512vbmi2intrin.h is not found.
+#define IS_UTF8_COMPILER_SUPPORTS_VBMI2 1
+#endif
+#endif
+
+// We allow icelake on x64 as long as the compiler is known to support VBMI2.
+#ifndef IS_UTF8_IMPLEMENTATION_ICELAKE
+#define IS_UTF8_IMPLEMENTATION_ICELAKE                                         \
+  ((IS_UTF8_IS_X86_64) && (IS_UTF8_COMPILER_SUPPORTS_VBMI2))
+#endif
+
+// To see why  (__BMI__) && (__PCLMUL__) && (__LZCNT__) are not part of this
+// next line, see https://github.com/simdutf/simdutf/issues/1247
+#define IS_UTF8_CAN_ALWAYS_RUN_ICELAKE                                         \
+  ((IS_UTF8_IMPLEMENTATION_ICELAKE) && (IS_UTF8_IS_X86_64) && (__AVX2__) &&    \
+   (IS_UTF8_HAS_AVX512F && IS_UTF8_HAS_AVX512DQ && IS_UTF8_HAS_AVX512VL &&     \
+    IS_UTF8_HAS_AVX512VBMI2) &&                                                \
+   (!IS_UTF8_IS_32BITS))
+
+#if IS_UTF8_IMPLEMENTATION_ICELAKE
+#if IS_UTF8_CAN_ALWAYS_RUN_ICELAKE
+#define IS_UTF8_TARGET_ICELAKE
+#define IS_UTF8_UNTARGET_ICELAKE
+#else
+#define IS_UTF8_TARGET_ICELAKE                                                 \
+  IS_UTF8_TARGET_REGION("avx512f,avx512dq,avx512cd,avx512bw,avx512vbmi,"       \
+                        "avx512vbmi2,avx512vl,avx2,bmi,bmi2,pclmul,lzcnt")
+#define IS_UTF8_UNTARGET_ICELAKE IS_UTF8_UNTARGET_REGION
+#endif
+
+namespace is_utf8_internals {
+namespace icelake {} // namespace icelake
+} // namespace is_utf8_internals
+
+//
+// These two need to be included outside IS_UTF8_TARGET_REGION
+//
+
+#ifndef IS_UTF8_ICELAKE_INTRINSICS_H
+#define IS_UTF8_ICELAKE_INTRINSICS_H
+
+#ifdef IS_UTF8_VISUAL_STUDIO
+// under clang within visual studio, this will include <x86intrin.h>
+#include <immintrin.h>
+#include <intrin.h> // visual studio or clang
+#else
+
+#if IS_UTF8_GCC11ORMORE
+// We should not get warnings while including <x86intrin.h> yet we do
+// under some versions of GCC.
+// If the x86intrin.h header has uninitialized values that are problematic,
+// it is a GCC issue, we want to ignore these warnigns.
+IS_UTF8_DISABLE_GCC_WARNING(-Wuninitialized)
+#endif
+
+#include <x86intrin.h> // elsewhere
+
+#if IS_UTF8_GCC11ORMORE
+// cancels the suppression of the -Wuninitialized
+IS_UTF8_POP_DISABLE_WARNINGS
+#endif
+
+#ifndef _tzcnt_u64
+#define _tzcnt_u64(x) __tzcnt_u64(x)
+#endif // _tzcnt_u64
+#endif // IS_UTF8_VISUAL_STUDIO
+
+#ifdef IS_UTF8_CLANG_VISUAL_STUDIO
+
+#include <avx2intrin.h>
+#include <avxintrin.h>
+#include <bmi2intrin.h>  // for _pext_u64, _pdep_u64
+#include <bmiintrin.h>   // for _blsr_u64
+#include <immintrin.h>   // for most things (AVX2, AVX512, _popcnt64)
+#include <lzcntintrin.h> // for  __lzcnt64
+#include <smmintrin.h>
+#include <tmmintrin.h>
+#include <wmmintrin.h> // for  _mm_clmulepi64_si128
+// Important: we need the AVX-512 headers:
+#include <avx512bwintrin.h>
+#include <avx512cdintrin.h>
+#include <avx512dqintrin.h>
+#include <avx512fintrin.h>
+#include <avx512vbmi2intrin.h>
+#include <avx512vbmiintrin.h>
+#include <avx512vlbwintrin.h>
+#include <avx512vlintrin.h>
+// unfortunately, we may not get _blsr_u64, but, thankfully, clang
+// has it as a macro.
+#ifndef _blsr_u64
+// we roll our own
+#define _blsr_u64(n) ((n - 1) & n)
+#endif //  _blsr_u64
+#endif // IS_UTF8_CLANG_VISUAL_STUDIO
+
+#if defined(__GNUC__) && !defined(__clang__)
+
+#if __GNUC__ == 8
+#define IS_UTF8_GCC8 1
+#elif __GNUC__ == 9
+#define IS_UTF8_GCC9 1
+#endif //  __GNUC__ == 8 || __GNUC__ == 9
+
+#endif // defined(__GNUC__) && !defined(__clang__)
+
+#if IS_UTF8_GCC8
+#pragma GCC push_options
+#pragma GCC target("avx512f")
+/**
+ * GCC 8 fails to provide _mm512_set_epi8. We roll our own.
+ */
+inline __m512i
+_mm512_set_epi8(uint8_t a0, uint8_t a1, uint8_t a2, uint8_t a3, uint8_t a4,
+                uint8_t a5, uint8_t a6, uint8_t a7, uint8_t a8, uint8_t a9,
+                uint8_t a10, uint8_t a11, uint8_t a12, uint8_t a13, uint8_t a14,
+                uint8_t a15, uint8_t a16, uint8_t a17, uint8_t a18, uint8_t a19,
+                uint8_t a20, uint8_t a21, uint8_t a22, uint8_t a23, uint8_t a24,
+                uint8_t a25, uint8_t a26, uint8_t a27, uint8_t a28, uint8_t a29,
+                uint8_t a30, uint8_t a31, uint8_t a32, uint8_t a33, uint8_t a34,
+                uint8_t a35, uint8_t a36, uint8_t a37, uint8_t a38, uint8_t a39,
+                uint8_t a40, uint8_t a41, uint8_t a42, uint8_t a43, uint8_t a44,
+                uint8_t a45, uint8_t a46, uint8_t a47, uint8_t a48, uint8_t a49,
+                uint8_t a50, uint8_t a51, uint8_t a52, uint8_t a53, uint8_t a54,
+                uint8_t a55, uint8_t a56, uint8_t a57, uint8_t a58, uint8_t a59,
+                uint8_t a60, uint8_t a61, uint8_t a62, uint8_t a63) {
+  return _mm512_set_epi64(
+      uint64_t(a7) + (uint64_t(a6) << 8) + (uint64_t(a5) << 16) +
+          (uint64_t(a4) << 24) + (uint64_t(a3) << 32) + (uint64_t(a2) << 40) +
+          (uint64_t(a1) << 48) + (uint64_t(a0) << 56),
+      uint64_t(a15) + (uint64_t(a14) << 8) + (uint64_t(a13) << 16) +
+          (uint64_t(a12) << 24) + (uint64_t(a11) << 32) +
+          (uint64_t(a10) << 40) + (uint64_t(a9) << 48) + (uint64_t(a8) << 56),
+      uint64_t(a23) + (uint64_t(a22) << 8) + (uint64_t(a21) << 16) +
+          (uint64_t(a20) << 24) + (uint64_t(a19) << 32) +
+          (uint64_t(a18) << 40) + (uint64_t(a17) << 48) + (uint64_t(a16) << 56),
+      uint64_t(a31) + (uint64_t(a30) << 8) + (uint64_t(a29) << 16) +
+          (uint64_t(a28) << 24) + (uint64_t(a27) << 32) +
+          (uint64_t(a26) << 40) + (uint64_t(a25) << 48) + (uint64_t(a24) << 56),
+      uint64_t(a39) + (uint64_t(a38) << 8) + (uint64_t(a37) << 16) +
+          (uint64_t(a36) << 24) + (uint64_t(a35) << 32) +
+          (uint64_t(a34) << 40) + (uint64_t(a33) << 48) + (uint64_t(a32) << 56),
+      uint64_t(a47) + (uint64_t(a46) << 8) + (uint64_t(a45) << 16) +
+          (uint64_t(a44) << 24) + (uint64_t(a43) << 32) +
+          (uint64_t(a42) << 40) + (uint64_t(a41) << 48) + (uint64_t(a40) << 56),
+      uint64_t(a55) + (uint64_t(a54) << 8) + (uint64_t(a53) << 16) +
+          (uint64_t(a52) << 24) + (uint64_t(a51) << 32) +
+          (uint64_t(a50) << 40) + (uint64_t(a49) << 48) + (uint64_t(a48) << 56),
+      uint64_t(a63) + (uint64_t(a62) << 8) + (uint64_t(a61) << 16) +
+          (uint64_t(a60) << 24) + (uint64_t(a59) << 32) +
+          (uint64_t(a58) << 40) + (uint64_t(a57) << 48) +
+          (uint64_t(a56) << 56));
+}
+#pragma GCC pop_options
+#endif // IS_UTF8_GCC8
+
+#endif // IS_UTF8_HASWELL_INTRINSICS_H
+
+#ifndef IS_UTF8_ICELAKE_IMPLEMENTATION_H
+#define IS_UTF8_ICELAKE_IMPLEMENTATION_H
+
+namespace is_utf8_internals {
+namespace icelake {
+
+class implementation final : public is_utf8_internals::implementation {
+public:
+  is_utf8_really_inline implementation()
+      : is_utf8_internals::implementation(
+            "icelake",
+            "Intel AVX512 (AVX-512BW, AVX-512CD, AVX-512VL, AVX-512VBMI2 "
+            "extensions)",
+            internal::instruction_set::AVX2 |
+                internal::instruction_set::PCLMULQDQ |
+                internal::instruction_set::BMI1 |
+                internal::instruction_set::BMI2 |
+                internal::instruction_set::AVX512BW |
+                internal::instruction_set::AVX512CD |
+                internal::instruction_set::AVX512VL |
+                internal::instruction_set::AVX512VBMI2) {}
+  is_utf8_warn_unused bool validate_utf8(const char *buf,
+                                         size_t len) const noexcept final;
+};
+
+} // namespace icelake
+} // namespace is_utf8_internals
+
+#endif // IS_UTF8_ICELAKE_IMPLEMENTATION_H
+
+#if IS_UTF8_GCC11ORMORE // workaround for
+                        // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=105593
+IS_UTF8_POP_DISABLE_WARNINGS
+#endif // end of workaround
+
+#endif // IS_UTF8_IMPLEMENTATION_ICELAKE
+#endif // IS_UTF8_ICELAKE_H
+
+#ifndef IS_UTF8_HASWELL_H
+#define IS_UTF8_HASWELL_H
+
+#ifdef IS_UTF8_WESTMERE_H
+#error "haswell.h must be included before westmere.h"
+#endif
+#ifdef IS_UTF8_FALLBACK_H
+#error "haswell.h must be included before fallback.h"
+#endif
+
+// Default Haswell to on if this is x86-64. Even if we're not compiled for it,
+// it could be selected at runtime.
+#ifndef IS_UTF8_IMPLEMENTATION_HASWELL
+//
+// You do not want to restrict it like so: IS_UTF8_IS_X86_64 && __AVX2__
+// because we want to rely on *runtime dispatch*.
+//
+#if IS_UTF8_CAN_ALWAYS_RUN_ICELAKE
+#define IS_UTF8_IMPLEMENTATION_HASWELL 0
+#else
+#define IS_UTF8_IMPLEMENTATION_HASWELL (IS_UTF8_IS_X86_64)
+#endif
+
+#endif
+// To see why  (__BMI__) && (__PCLMUL__) && (__LZCNT__) are not part of this
+// next line, see https://github.com/simdutf/simdutf/issues/1247
+#define IS_UTF8_CAN_ALWAYS_RUN_HASWELL                                         \
+  ((IS_UTF8_IMPLEMENTATION_HASWELL) && (IS_UTF8_IS_X86_64) && (__AVX2__))
+
+#if IS_UTF8_IMPLEMENTATION_HASWELL
+
+#define IS_UTF8_TARGET_HASWELL IS_UTF8_TARGET_REGION("avx2,bmi,pclmul,lzcnt")
+
+namespace is_utf8_internals {
+/**
+ * Implementation for Haswell (Intel AVX2).
+ */
+namespace haswell {} // namespace haswell
+} // namespace is_utf8_internals
+
+//
+// These two need to be included outside IS_UTF8_TARGET_REGION
+//
+
+#ifndef IS_UTF8_HASWELL_IMPLEMENTATION_H
+#define IS_UTF8_HASWELL_IMPLEMENTATION_H
+
+// The constructor may be executed on any host, so we take care not to use
+// IS_UTF8_TARGET_REGION
+namespace is_utf8_internals {
+namespace haswell {
+
+class implementation final : public is_utf8_internals::implementation {
+public:
+  is_utf8_really_inline implementation()
+      : is_utf8_internals::implementation(
+            "haswell", "Intel/AMD AVX2",
+            internal::instruction_set::AVX2 |
+                internal::instruction_set::PCLMULQDQ |
+                internal::instruction_set::BMI1 |
+                internal::instruction_set::BMI2) {}
+  is_utf8_warn_unused bool validate_utf8(const char *buf,
+                                         size_t len) const noexcept final;
+};
+
+} // namespace haswell
+} // namespace is_utf8_internals
+
+#endif // IS_UTF8_HASWELL_IMPLEMENTATION_H
+
+#ifndef IS_UTF8_HASWELL_INTRINSICS_H
+#define IS_UTF8_HASWELL_INTRINSICS_H
+
+#ifdef IS_UTF8_VISUAL_STUDIO
+// under clang within visual studio, this will include <x86intrin.h>
+#include <intrin.h> // visual studio or clang
+#else
+
+#if IS_UTF8_GCC11ORMORE
+// We should not get warnings while including <x86intrin.h> yet we do
+// under some versions of GCC.
+// If the x86intrin.h header has uninitialized values that are problematic,
+// it is a GCC issue, we want to ignore these warnigns.
+IS_UTF8_DISABLE_GCC_WARNING(-Wuninitialized)
+#endif
+
+#include <x86intrin.h> // elsewhere
+
+#if IS_UTF8_GCC11ORMORE
+// cancels the suppression of the -Wuninitialized
+IS_UTF8_POP_DISABLE_WARNINGS
+#endif
+
+#endif // IS_UTF8_VISUAL_STUDIO
+
+#ifdef IS_UTF8_CLANG_VISUAL_STUDIO
+
+#include <avx2intrin.h>
+#include <avxintrin.h>
+#include <bmiintrin.h>   // for _blsr_u64
+#include <immintrin.h>   // for most things (AVX2, AVX512, _popcnt64)
+#include <lzcntintrin.h> // for  __lzcnt64
+#include <smmintrin.h>
+#include <tmmintrin.h>
+#include <wmmintrin.h> // for  _mm_clmulepi64_si128
+// unfortunately, we may not get _blsr_u64, but, thankfully, clang
+// has it as a macro.
+#ifndef _blsr_u64
+// we roll our own
+#define _blsr_u64(n) ((n - 1) & n)
+#endif //  _blsr_u64
+#endif // IS_UTF8_CLANG_VISUAL_STUDIO
+
+#endif // IS_UTF8_HASWELL_INTRINSICS_H
+
+//
+// The rest need to be inside the region
+//
+
+// redefining IS_UTF8_IMPLEMENTATION to "haswell"
+// #define IS_UTF8_IMPLEMENTATION haswell
+IS_UTF8_TARGET_HASWELL
+
+#if IS_UTF8_GCC11ORMORE // workaround for
+                        // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=105593
+IS_UTF8_DISABLE_GCC_WARNING(-Wmaybe-uninitialized)
+#endif // end of workaround
+
+// Declarations
+
+#ifndef IS_UTF8_HASWELL_SIMD_H
+#define IS_UTF8_HASWELL_SIMD_H
+
+namespace is_utf8_internals {
+namespace haswell {
+namespace {
+namespace simd {
+
+// Forward-declared so they can be used by splat and friends.
+template <typename Child> struct base {
+  __m256i value;
+
+  // Zero constructor
+  is_utf8_really_inline base() : value{__m256i()} {}
+
+  // Conversion from SIMD register
+  is_utf8_really_inline base(const __m256i _value) : value(_value) {}
+  // Conversion to SIMD register
+  is_utf8_really_inline operator const __m256i &() const { return this->value; }
+  is_utf8_really_inline operator __m256i &() { return this->value; }
+  template <endianness big_endian>
+  is_utf8_really_inline void store_ascii_as_utf16(char16_t *ptr) const {
+    __m256i first = _mm256_cvtepu8_epi16(_mm256_castsi256_si128(*this));
+    __m256i second = _mm256_cvtepu8_epi16(_mm256_extractf128_si256(*this, 1));
+    if (big_endian) {
+      const __m256i swap = _mm256_setr_epi8(
+          1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14, 17, 16, 19, 18,
+          21, 20, 23, 22, 25, 24, 27, 26, 29, 28, 31, 30);
+      first = _mm256_shuffle_epi8(first, swap);
+      second = _mm256_shuffle_epi8(second, swap);
+    }
+    _mm256_storeu_si256(reinterpret_cast<__m256i *>(ptr), first);
+    _mm256_storeu_si256(reinterpret_cast<__m256i *>(ptr + 16), second);
+  }
+  is_utf8_really_inline void store_ascii_as_utf32(char32_t *ptr) const {
+    _mm256_storeu_si256(reinterpret_cast<__m256i *>(ptr),
+                        _mm256_cvtepu8_epi32(_mm256_castsi256_si128(*this)));
+    _mm256_storeu_si256(reinterpret_cast<__m256i *>(ptr + 8),
+                        _mm256_cvtepu8_epi32(_mm256_castsi256_si128(
+                            _mm256_srli_si256(*this, 8))));
+    _mm256_storeu_si256(
+        reinterpret_cast<__m256i *>(ptr + 16),
+        _mm256_cvtepu8_epi32(_mm256_extractf128_si256(*this, 1)));
+    _mm256_storeu_si256(reinterpret_cast<__m256i *>(ptr + 24),
+                        _mm256_cvtepu8_epi32(_mm_srli_si128(
+                            _mm256_extractf128_si256(*this, 1), 8)));
+  }
+  // Bit operations
+  is_utf8_really_inline Child operator|(const Child other) const {
+    return _mm256_or_si256(*this, other);
+  }
+  is_utf8_really_inline Child operator&(const Child other) const {
+    return _mm256_and_si256(*this, other);
+  }
+  is_utf8_really_inline Child operator^(const Child other) const {
+    return _mm256_xor_si256(*this, other);
+  }
+  is_utf8_really_inline Child bit_andnot(const Child other) const {
+    return _mm256_andnot_si256(other, *this);
+  }
+  is_utf8_really_inline Child &operator|=(const Child other) {
+    auto this_cast = static_cast<Child *>(this);
+    *this_cast = *this_cast | other;
+    return *this_cast;
+  }
+  is_utf8_really_inline Child &operator&=(const Child other) {
+    auto this_cast = static_cast<Child *>(this);
+    *this_cast = *this_cast & other;
+    return *this_cast;
+  }
+  is_utf8_really_inline Child &operator^=(const Child other) {
+    auto this_cast = static_cast<Child *>(this);
+    *this_cast = *this_cast ^ other;
+    return *this_cast;
+  }
+};
+
+// Forward-declared so they can be used by splat and friends.
+template <typename T> struct simd8;
+
+template <typename T, typename Mask = simd8<bool>>
+struct base8 : base<simd8<T>> {
+  typedef uint32_t bitmask_t;
+  typedef uint64_t bitmask2_t;
+
+  is_utf8_really_inline base8() : base<simd8<T>>() {}
+  is_utf8_really_inline base8(const __m256i _value) : base<simd8<T>>(_value) {}
+  is_utf8_really_inline T first() const {
+    return _mm256_extract_epi8(*this, 0);
+  }
+  is_utf8_really_inline T last() const {
+    return _mm256_extract_epi8(*this, 31);
+  }
+  is_utf8_really_inline Mask operator==(const simd8<T> other) const {
+    return _mm256_cmpeq_epi8(*this, other);
+  }
+
+  static const int SIZE = sizeof(base<T>::value);
+
+  template <int N = 1>
+  is_utf8_really_inline simd8<T> prev(const simd8<T> prev_chunk) const {
+    return _mm256_alignr_epi8(
+        *this, _mm256_permute2x128_si256(prev_chunk, *this, 0x21), 16 - N);
+  }
+};
+
+// SIMD byte mask type (returned by things like eq and gt)
+template <> struct simd8<bool> : base8<bool> {
+  static is_utf8_really_inline simd8<bool> splat(bool _value) {
+    return _mm256_set1_epi8(uint8_t(-(!!_value)));
+  }
+
+  is_utf8_really_inline simd8<bool>() : base8() {}
+  is_utf8_really_inline simd8<bool>(const __m256i _value)
+      : base8<bool>(_value) {}
+  // Splat constructor
+  is_utf8_really_inline simd8<bool>(bool _value) : base8<bool>(splat(_value)) {}
+
+  is_utf8_really_inline uint32_t to_bitmask() const {
+    return uint32_t(_mm256_movemask_epi8(*this));
+  }
+  is_utf8_really_inline bool any() const {
+    return !_mm256_testz_si256(*this, *this);
+  }
+  is_utf8_really_inline bool none() const {
+    return _mm256_testz_si256(*this, *this);
+  }
+  is_utf8_really_inline bool all() const {
+    return static_cast<uint32_t>(_mm256_movemask_epi8(*this)) == 0xFFFFFFFF;
+  }
+  is_utf8_really_inline simd8<bool> operator~() const { return *this ^ true; }
+};
+
+template <typename T> struct base8_numeric : base8<T> {
+  static is_utf8_really_inline simd8<T> splat(T _value) {
+    return _mm256_set1_epi8(_value);
+  }
+  static is_utf8_really_inline simd8<T> zero() {
+    return _mm256_setzero_si256();
+  }
+  static is_utf8_really_inline simd8<T> load(const T values[32]) {
+    return _mm256_loadu_si256(reinterpret_cast<const __m256i *>(values));
+  }
+  // Repeat 16 values as many times as necessary (usually for lookup tables)
+  static is_utf8_really_inline simd8<T> repeat_16(T v0, T v1, T v2, T v3, T v4,
+                                                  T v5, T v6, T v7, T v8, T v9,
+                                                  T v10, T v11, T v12, T v13,
+                                                  T v14, T v15) {
+    return simd8<T>(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13,
+                    v14, v15, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11,
+                    v12, v13, v14, v15);
+  }
+
+  is_utf8_really_inline base8_numeric() : base8<T>() {}
+  is_utf8_really_inline base8_numeric(const __m256i _value)
+      : base8<T>(_value) {}
+
+  // Store to array
+  is_utf8_really_inline void store(T dst[32]) const {
+    return _mm256_storeu_si256(reinterpret_cast<__m256i *>(dst), *this);
+  }
+
+  // Addition/subtraction are the same for signed and unsigned
+  is_utf8_really_inline simd8<T> operator+(const simd8<T> other) const {
+    return _mm256_add_epi8(*this, other);
+  }
+  is_utf8_really_inline simd8<T> operator-(const simd8<T> other) const {
+    return _mm256_sub_epi8(*this, other);
+  }
+  is_utf8_really_inline simd8<T> &operator+=(const simd8<T> other) {
+    *this = *this + other;
+    return *static_cast<simd8<T> *>(this);
+  }
+  is_utf8_really_inline simd8<T> &operator-=(const simd8<T> other) {
+    *this = *this - other;
+    return *static_cast<simd8<T> *>(this);
+  }
+
+  // Override to distinguish from bool version
+  is_utf8_really_inline simd8<T> operator~() const { return *this ^ 0xFFu; }
+
+  // Perform a lookup assuming the value is between 0 and 16 (undefined behavior
+  // for out of range values)
+  template <typename L>
+  is_utf8_really_inline simd8<L> lookup_16(simd8<L> lookup_table) const {
+    return _mm256_shuffle_epi8(lookup_table, *this);
+  }
+
+  template <typename L>
+  is_utf8_really_inline simd8<L>
+  lookup_16(L replace0, L replace1, L replace2, L replace3, L replace4,
+            L replace5, L replace6, L replace7, L replace8, L replace9,
+            L replace10, L replace11, L replace12, L replace13, L replace14,
+            L replace15) const {
+    return lookup_16(simd8<L>::repeat_16(
+        replace0, replace1, replace2, replace3, replace4, replace5, replace6,
+        replace7, replace8, replace9, replace10, replace11, replace12,
+        replace13, replace14, replace15));
+  }
+};
+
+// Signed bytes
+template <> struct simd8<int8_t> : base8_numeric<int8_t> {
+  is_utf8_really_inline simd8() : base8_numeric<int8_t>() {}
+  is_utf8_really_inline simd8(const __m256i _value)
+      : base8_numeric<int8_t>(_value) {}
+
+  // Splat constructor
+  is_utf8_really_inline simd8(int8_t _value) : simd8(splat(_value)) {}
+  // Array constructor
+  is_utf8_really_inline simd8(const int8_t values[32]) : simd8(load(values)) {}
+  is_utf8_really_inline operator simd8<uint8_t>() const;
+  // Member-by-member initialization
+  is_utf8_really_inline
+  simd8(int8_t v0, int8_t v1, int8_t v2, int8_t v3, int8_t v4, int8_t v5,
+        int8_t v6, int8_t v7, int8_t v8, int8_t v9, int8_t v10, int8_t v11,
+        int8_t v12, int8_t v13, int8_t v14, int8_t v15, int8_t v16, int8_t v17,
+        int8_t v18, int8_t v19, int8_t v20, int8_t v21, int8_t v22, int8_t v23,
+        int8_t v24, int8_t v25, int8_t v26, int8_t v27, int8_t v28, int8_t v29,
+        int8_t v30, int8_t v31)
+      : simd8(_mm256_setr_epi8(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11,
+                               v12, v13, v14, v15, v16, v17, v18, v19, v20, v21,
+                               v22, v23, v24, v25, v26, v27, v28, v29, v30,
+                               v31)) {}
+  // Repeat 16 values as many times as necessary (usually for lookup tables)
+  is_utf8_really_inline static simd8<int8_t>
+  repeat_16(int8_t v0, int8_t v1, int8_t v2, int8_t v3, int8_t v4, int8_t v5,
+            int8_t v6, int8_t v7, int8_t v8, int8_t v9, int8_t v10, int8_t v11,
+            int8_t v12, int8_t v13, int8_t v14, int8_t v15) {
+    return simd8<int8_t>(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12,
+                         v13, v14, v15, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9,
+                         v10, v11, v12, v13, v14, v15);
+  }
+  is_utf8_really_inline bool is_ascii() const {
+    return _mm256_movemask_epi8(*this) == 0;
+  }
+  // Order-sensitive comparisons
+  is_utf8_really_inline simd8<int8_t> max_val(const simd8<int8_t> other) const {
+    return _mm256_max_epi8(*this, other);
+  }
+  is_utf8_really_inline simd8<int8_t> min_val(const simd8<int8_t> other) const {
+    return _mm256_min_epi8(*this, other);
+  }
+  is_utf8_really_inline simd8<bool> operator>(const simd8<int8_t> other) const {
+    return _mm256_cmpgt_epi8(*this, other);
+  }
+  is_utf8_really_inline simd8<bool> operator<(const simd8<int8_t> other) const {
+    return _mm256_cmpgt_epi8(other, *this);
+  }
+};
+
+// Unsigned bytes
+template <> struct simd8<uint8_t> : base8_numeric<uint8_t> {
+  is_utf8_really_inline simd8() : base8_numeric<uint8_t>() {}
+  is_utf8_really_inline simd8(const __m256i _value)
+      : base8_numeric<uint8_t>(_value) {}
+  // Splat constructor
+  is_utf8_really_inline simd8(uint8_t _value) : simd8(splat(_value)) {}
+  // Array constructor
+  is_utf8_really_inline simd8(const uint8_t values[32]) : simd8(load(values)) {}
+  // Member-by-member initialization
+  is_utf8_really_inline
+  simd8(uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3, uint8_t v4, uint8_t v5,
+        uint8_t v6, uint8_t v7, uint8_t v8, uint8_t v9, uint8_t v10,
+        uint8_t v11, uint8_t v12, uint8_t v13, uint8_t v14, uint8_t v15,
+        uint8_t v16, uint8_t v17, uint8_t v18, uint8_t v19, uint8_t v20,
+        uint8_t v21, uint8_t v22, uint8_t v23, uint8_t v24, uint8_t v25,
+        uint8_t v26, uint8_t v27, uint8_t v28, uint8_t v29, uint8_t v30,
+        uint8_t v31)
+      : simd8(_mm256_setr_epi8(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11,
+                               v12, v13, v14, v15, v16, v17, v18, v19, v20, v21,
+                               v22, v23, v24, v25, v26, v27, v28, v29, v30,
+                               v31)) {}
+  // Repeat 16 values as many times as necessary (usually for lookup tables)
+  is_utf8_really_inline static simd8<uint8_t>
+  repeat_16(uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3, uint8_t v4,
+            uint8_t v5, uint8_t v6, uint8_t v7, uint8_t v8, uint8_t v9,
+            uint8_t v10, uint8_t v11, uint8_t v12, uint8_t v13, uint8_t v14,
+            uint8_t v15) {
+    return simd8<uint8_t>(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12,
+                          v13, v14, v15, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9,
+                          v10, v11, v12, v13, v14, v15);
+  }
+
+  // Saturated math
+  is_utf8_really_inline simd8<uint8_t>
+  saturating_add(const simd8<uint8_t> other) const {
+    return _mm256_adds_epu8(*this, other);
+  }
+  is_utf8_really_inline simd8<uint8_t>
+  saturating_sub(const simd8<uint8_t> other) const {
+    return _mm256_subs_epu8(*this, other);
+  }
+
+  // Order-specific operations
+  is_utf8_really_inline simd8<uint8_t>
+  max_val(const simd8<uint8_t> other) const {
+    return _mm256_max_epu8(*this, other);
+  }
+  is_utf8_really_inline simd8<uint8_t>
+  min_val(const simd8<uint8_t> other) const {
+    return _mm256_min_epu8(other, *this);
+  }
+  // Same as >, but only guarantees true is nonzero (< guarantees true = -1)
+  is_utf8_really_inline simd8<uint8_t>
+  gt_bits(const simd8<uint8_t> other) const {
+    return this->saturating_sub(other);
+  }
+  // Same as <, but only guarantees true is nonzero (< guarantees true = -1)
+  is_utf8_really_inline simd8<uint8_t>
+  lt_bits(const simd8<uint8_t> other) const {
+    return other.saturating_sub(*this);
+  }
+  is_utf8_really_inline simd8<bool>
+  operator<=(const simd8<uint8_t> other) const {
+    return other.max_val(*this) == other;
+  }
+  is_utf8_really_inline simd8<bool>
+  operator>=(const simd8<uint8_t> other) const {
+    return other.min_val(*this) == other;
+  }
+  is_utf8_really_inline simd8<bool>
+  operator>(const simd8<uint8_t> other) const {
+    return this->gt_bits(other).any_bits_set();
+  }
+  is_utf8_really_inline simd8<bool>
+  operator<(const simd8<uint8_t> other) const {
+    return this->lt_bits(other).any_bits_set();
+  }
+
+  // Bit-specific operations
+  is_utf8_really_inline simd8<bool> bits_not_set() const {
+    return *this == uint8_t(0);
+  }
+  is_utf8_really_inline simd8<bool> bits_not_set(simd8<uint8_t> bits) const {
+    return (*this & bits).bits_not_set();
+  }
+  is_utf8_really_inline simd8<bool> any_bits_set() const {
+    return ~this->bits_not_set();
+  }
+  is_utf8_really_inline simd8<bool> any_bits_set(simd8<uint8_t> bits) const {
+    return ~this->bits_not_set(bits);
+  }
+  is_utf8_really_inline bool is_ascii() const {
+    return _mm256_movemask_epi8(*this) == 0;
+  }
+  is_utf8_really_inline bool bits_not_set_anywhere() const {
+    return _mm256_testz_si256(*this, *this);
+  }
+  is_utf8_really_inline bool any_bits_set_anywhere() const {
+    return !bits_not_set_anywhere();
+  }
+  is_utf8_really_inline bool bits_not_set_anywhere(simd8<uint8_t> bits) const {
+    return _mm256_testz_si256(*this, bits);
+  }
+  is_utf8_really_inline bool any_bits_set_anywhere(simd8<uint8_t> bits) const {
+    return !bits_not_set_anywhere(bits);
+  }
+  template <int N> is_utf8_really_inline simd8<uint8_t> shr() const {
+    return simd8<uint8_t>(_mm256_srli_epi16(*this, N)) & uint8_t(0xFFu >> N);
+  }
+  template <int N> is_utf8_really_inline simd8<uint8_t> shl() const {
+    return simd8<uint8_t>(_mm256_slli_epi16(*this, N)) & uint8_t(0xFFu << N);
+  }
+  // Get one of the bits and make a bitmask out of it.
+  // e.g. value.get_bit<7>() gets the high bit
+  template <int N> is_utf8_really_inline int get_bit() const {
+    return _mm256_movemask_epi8(_mm256_slli_epi16(*this, 7 - N));
+  }
+};
+is_utf8_really_inline simd8<int8_t>::operator simd8<uint8_t>() const {
+  return this->value;
+}
+
+template <typename T> struct simd8x64 {
+  static constexpr int NUM_CHUNKS = 64 / sizeof(simd8<T>);
+  static_assert(NUM_CHUNKS == 2,
+                "Haswell kernel should use two registers per 64-byte block.");
+  simd8<T> chunks[NUM_CHUNKS];
+
+  simd8x64(const simd8x64<T> &o) = delete; // no copy allowed
+  simd8x64<T> &
+  operator=(const simd8<T> other) = delete; // no assignment allowed
+  simd8x64() = delete;                      // no default constructor allowed
+
+  is_utf8_really_inline simd8x64(const simd8<T> chunk0, const simd8<T> chunk1)
+      : chunks{chunk0, chunk1} {}
+  is_utf8_really_inline simd8x64(const T *ptr)
+      : chunks{simd8<T>::load(ptr),
+               simd8<T>::load(ptr + sizeof(simd8<T>) / sizeof(T))} {}
+
+  is_utf8_really_inline void store(T *ptr) const {
+    this->chunks[0].store(ptr + sizeof(simd8<T>) * 0 / sizeof(T));
+    this->chunks[1].store(ptr + sizeof(simd8<T>) * 1 / sizeof(T));
+  }
+
+  is_utf8_really_inline uint64_t to_bitmask() const {
+    uint64_t r_lo = uint32_t(this->chunks[0].to_bitmask());
+    uint64_t r_hi = this->chunks[1].to_bitmask();
+    return r_lo | (r_hi << 32);
+  }
+
+  is_utf8_really_inline simd8x64<T> &operator|=(const simd8x64<T> &other) {
+    this->chunks[0] |= other.chunks[0];
+    this->chunks[1] |= other.chunks[1];
+    return *this;
+  }
+
+  is_utf8_really_inline simd8<T> reduce_or() const {
+    return this->chunks[0] | this->chunks[1];
+  }
+
+  is_utf8_really_inline bool is_ascii() const {
+    return this->reduce_or().is_ascii();
+  }
+
+  template <endianness endian>
+  is_utf8_really_inline void store_ascii_as_utf16(char16_t *ptr) const {
+    this->chunks[0].template store_ascii_as_utf16<endian>(ptr +
+                                                          sizeof(simd8<T>) * 0);
+    this->chunks[1].template store_ascii_as_utf16<endian>(ptr +
+                                                          sizeof(simd8<T>) * 1);
+  }
+
+  is_utf8_really_inline void store_ascii_as_utf32(char32_t *ptr) const {
+    this->chunks[0].store_ascii_as_utf32(ptr + sizeof(simd8<T>) * 0);
+    this->chunks[1].store_ascii_as_utf32(ptr + sizeof(simd8<T>) * 1);
+  }
+
+  is_utf8_really_inline simd8x64<T> bit_or(const T m) const {
+    const simd8<T> mask = simd8<T>::splat(m);
+    return simd8x64<T>(this->chunks[0] | mask, this->chunks[1] | mask);
+  }
+
+  is_utf8_really_inline uint64_t eq(const T m) const {
+    const simd8<T> mask = simd8<T>::splat(m);
+    return simd8x64<bool>(this->chunks[0] == mask, this->chunks[1] == mask)
+        .to_bitmask();
+  }
+
+  is_utf8_really_inline uint64_t eq(const simd8x64<uint8_t> &other) const {
+    return simd8x64<bool>(this->chunks[0] == other.chunks[0],
+                          this->chunks[1] == other.chunks[1])
+        .to_bitmask();
+  }
+
+  is_utf8_really_inline uint64_t lteq(const T m) const {
+    const simd8<T> mask = simd8<T>::splat(m);
+    return simd8x64<bool>(this->chunks[0] <= mask, this->chunks[1] <= mask)
+        .to_bitmask();
+  }
+
+  is_utf8_really_inline uint64_t in_range(const T low, const T high) const {
+    const simd8<T> mask_low = simd8<T>::splat(low);
+    const simd8<T> mask_high = simd8<T>::splat(high);
+
+    return simd8x64<bool>(
+               (this->chunks[0] <= mask_high) & (this->chunks[0] >= mask_low),
+               (this->chunks[1] <= mask_high) & (this->chunks[1] >= mask_low),
+               (this->chunks[2] <= mask_high) & (this->chunks[2] >= mask_low),
+               (this->chunks[3] <= mask_high) & (this->chunks[3] >= mask_low))
+        .to_bitmask();
+  }
+  is_utf8_really_inline uint64_t not_in_range(const T low, const T high) const {
+    const simd8<T> mask_low = simd8<T>::splat(low);
+    const simd8<T> mask_high = simd8<T>::splat(high);
+    return simd8x64<bool>(
+               (this->chunks[0] > mask_high) | (this->chunks[0] < mask_low),
+               (this->chunks[1] > mask_high) | (this->chunks[1] < mask_low))
+        .to_bitmask();
+  }
+  is_utf8_really_inline uint64_t lt(const T m) const {
+    const simd8<T> mask = simd8<T>::splat(m);
+    return simd8x64<bool>(this->chunks[0] < mask, this->chunks[1] < mask)
+        .to_bitmask();
+  }
+
+  is_utf8_really_inline uint64_t gt(const T m) const {
+    const simd8<T> mask = simd8<T>::splat(m);
+    return simd8x64<bool>(this->chunks[0] > mask, this->chunks[1] > mask)
+        .to_bitmask();
+  }
+  is_utf8_really_inline uint64_t gteq(const T m) const {
+    const simd8<T> mask = simd8<T>::splat(m);
+    return simd8x64<bool>(this->chunks[0] >= mask, this->chunks[1] >= mask)
+        .to_bitmask();
+  }
+  is_utf8_really_inline uint64_t gteq_unsigned(const uint8_t m) const {
+    const simd8<uint8_t> mask = simd8<uint8_t>::splat(m);
+    return simd8x64<bool>((simd8<uint8_t>(__m256i(this->chunks[0])) >= mask),
+                          (simd8<uint8_t>(__m256i(this->chunks[1])) >= mask))
+        .to_bitmask();
+  }
+}; // struct simd8x64<T>
+
+#ifdef __GNUC__
+#if __GNUC__ < 8
+#define _mm256_set_m128i(xmm1, xmm2)                                           \
+  _mm256_permute2f128_si256(_mm256_castsi128_si256(xmm1),                      \
+                            _mm256_castsi128_si256(xmm2), 2)
+#define _mm256_setr_m128i(xmm2, xmm1)                                          \
+  _mm256_permute2f128_si256(_mm256_castsi128_si256(xmm1),                      \
+                            _mm256_castsi128_si256(xmm2), 2)
+#endif
+#endif
+
+template <typename T> struct simd16;
+
+template <typename T, typename Mask = simd16<bool>>
+struct base16 : base<simd16<T>> {
+  using bitmask_type = uint32_t;
+
+  is_utf8_really_inline base16() : base<simd16<T>>() {}
+  is_utf8_really_inline base16(const __m256i _value)
+      : base<simd16<T>>(_value) {}
+  template <typename Pointer>
+  is_utf8_really_inline base16(const Pointer *ptr)
+      : base16(_mm256_loadu_si256(reinterpret_cast<const __m256i *>(ptr))) {}
+
+  is_utf8_really_inline Mask operator==(const simd16<T> other) const {
+    return _mm256_cmpeq_epi16(*this, other);
+  }
+
+  /// the size of vector in bytes
+  static const int SIZE = sizeof(base<simd16<T>>::value);
+
+  /// the number of elements of type T a vector can hold
+  static const int ELEMENTS = SIZE / sizeof(T);
+
+  template <int N = 1>
+  is_utf8_really_inline simd16<T> prev(const simd16<T> prev_chunk) const {
+    return _mm256_alignr_epi8(*this, prev_chunk, 16 - N);
+  }
+};
+
+// SIMD byte mask type (returned by things like eq and gt)
+template <> struct simd16<bool> : base16<bool> {
+  static is_utf8_really_inline simd16<bool> splat(bool _value) {
+    return _mm256_set1_epi16(uint16_t(-(!!_value)));
+  }
+
+  is_utf8_really_inline simd16<bool>() : base16() {}
+  is_utf8_really_inline simd16<bool>(const __m256i _value)
+      : base16<bool>(_value) {}
+  // Splat constructor
+  is_utf8_really_inline simd16<bool>(bool _value)
+      : base16<bool>(splat(_value)) {}
+
+  is_utf8_really_inline bitmask_type to_bitmask() const {
+    return _mm256_movemask_epi8(*this);
+  }
+  is_utf8_really_inline bool any() const {
+    return !_mm256_testz_si256(*this, *this);
+  }
+  is_utf8_really_inline simd16<bool> operator~() const { return *this ^ true; }
+};
+
+template <typename T> struct base16_numeric : base16<T> {
+  static is_utf8_really_inline simd16<T> splat(T _value) {
+    return _mm256_set1_epi16(_value);
+  }
+  static is_utf8_really_inline simd16<T> zero() {
+    return _mm256_setzero_si256();
+  }
+  static is_utf8_really_inline simd16<T> load(const T values[8]) {
+    return _mm256_loadu_si256(reinterpret_cast<const __m256i *>(values));
+  }
+
+  is_utf8_really_inline base16_numeric() : base16<T>() {}
+  is_utf8_really_inline base16_numeric(const __m256i _value)
+      : base16<T>(_value) {}
+
+  // Store to array
+  is_utf8_really_inline void store(T dst[8]) const {
+    return _mm256_storeu_si256(reinterpret_cast<__m256i *>(dst), *this);
+  }
+
+  // Override to distinguish from bool version
+  is_utf8_really_inline simd16<T> operator~() const { return *this ^ 0xFFFFu; }
+
+  // Addition/subtraction are the same for signed and unsigned
+  is_utf8_really_inline simd16<T> operator+(const simd16<T> other) const {
+    return _mm256_add_epi16(*this, other);
+  }
+  is_utf8_really_inline simd16<T> operator-(const simd16<T> other) const {
+    return _mm256_sub_epi16(*this, other);
+  }
+  is_utf8_really_inline simd16<T> &operator+=(const simd16<T> other) {
+    *this = *this + other;
+    return *static_cast<simd16<T> *>(this);
+  }
+  is_utf8_really_inline simd16<T> &operator-=(const simd16<T> other) {
+    *this = *this - other;
+    return *static_cast<simd16<T> *>(this);
+  }
+};
+
+// Signed words
+template <> struct simd16<int16_t> : base16_numeric<int16_t> {
+  is_utf8_really_inline simd16() : base16_numeric<int16_t>() {}
+  is_utf8_really_inline simd16(const __m256i _value)
+      : base16_numeric<int16_t>(_value) {}
+  // Splat constructor
+  is_utf8_really_inline simd16(int16_t _value) : simd16(splat(_value)) {}
+  // Array constructor
+  is_utf8_really_inline simd16(const int16_t *values) : simd16(load(values)) {}
+  is_utf8_really_inline simd16(const char16_t *values)
+      : simd16(load(reinterpret_cast<const int16_t *>(values))) {}
+  // Order-sensitive comparisons
+  is_utf8_really_inline simd16<int16_t>
+  max_val(const simd16<int16_t> other) const {
+    return _mm256_max_epi16(*this, other);
+  }
+  is_utf8_really_inline simd16<int16_t>
+  min_val(const simd16<int16_t> other) const {
+    return _mm256_min_epi16(*this, other);
+  }
+  is_utf8_really_inline simd16<bool>
+  operator>(const simd16<int16_t> other) const {
+    return _mm256_cmpgt_epi16(*this, other);
+  }
+  is_utf8_really_inline simd16<bool>
+  operator<(const simd16<int16_t> other) const {
+    return _mm256_cmpgt_epi16(other, *this);
+  }
+};
+
+// Unsigned words
+template <> struct simd16<uint16_t> : base16_numeric<uint16_t> {
+  is_utf8_really_inline simd16() : base16_numeric<uint16_t>() {}
+  is_utf8_really_inline simd16(const __m256i _value)
+      : base16_numeric<uint16_t>(_value) {}
+
+  // Splat constructor
+  is_utf8_really_inline simd16(uint16_t _value) : simd16(splat(_value)) {}
+  // Array constructor
+  is_utf8_really_inline simd16(const uint16_t *values) : simd16(load(values)) {}
+  is_utf8_really_inline simd16(const char16_t *values)
+      : simd16(load(reinterpret_cast<const uint16_t *>(values))) {}
+
+  // Saturated math
+  is_utf8_really_inline simd16<uint16_t>
+  saturating_add(const simd16<uint16_t> other) const {
+    return _mm256_adds_epu16(*this, other);
+  }
+  is_utf8_really_inline simd16<uint16_t>
+  saturating_sub(const simd16<uint16_t> other) const {
+    return _mm256_subs_epu16(*this, other);
+  }
+
+  // Order-specific operations
+  is_utf8_really_inline simd16<uint16_t>
+  max_val(const simd16<uint16_t> other) const {
+    return _mm256_max_epu16(*this, other);
+  }
+  is_utf8_really_inline simd16<uint16_t>
+  min_val(const simd16<uint16_t> other) const {
+    return _mm256_min_epu16(*this, other);
+  }
+  // Same as >, but only guarantees true is nonzero (< guarantees true = -1)
+  is_utf8_really_inline simd16<uint16_t>
+  gt_bits(const simd16<uint16_t> other) const {
+    return this->saturating_sub(other);
+  }
+  // Same as <, but only guarantees true is nonzero (< guarantees true = -1)
+  is_utf8_really_inline simd16<uint16_t>
+  lt_bits(const simd16<uint16_t> other) const {
+    return other.saturating_sub(*this);
+  }
+  is_utf8_really_inline simd16<bool>
+  operator<=(const simd16<uint16_t> other) const {
+    return other.max_val(*this) == other;
+  }
+  is_utf8_really_inline simd16<bool>
+  operator>=(const simd16<uint16_t> other) const {
+    return other.min_val(*this) == other;
+  }
+  is_utf8_really_inline simd16<bool>
+  operator>(const simd16<uint16_t> other) const {
+    return this->gt_bits(other).any_bits_set();
+  }
+  is_utf8_really_inline simd16<bool>
+  operator<(const simd16<uint16_t> other) const {
+    return this->gt_bits(other).any_bits_set();
+  }
+
+  // Bit-specific operations
+  is_utf8_really_inline simd16<bool> bits_not_set() const {
+    return *this == uint16_t(0);
+  }
+  is_utf8_really_inline simd16<bool> bits_not_set(simd16<uint16_t> bits) const {
+    return (*this & bits).bits_not_set();
+  }
+  is_utf8_really_inline simd16<bool> any_bits_set() const {
+    return ~this->bits_not_set();
+  }
+  is_utf8_really_inline simd16<bool> any_bits_set(simd16<uint16_t> bits) const {
+    return ~this->bits_not_set(bits);
+  }
+
+  is_utf8_really_inline bool bits_not_set_anywhere() const {
+    return _mm256_testz_si256(*this, *this);
+  }
+  is_utf8_really_inline bool any_bits_set_anywhere() const {
+    return !bits_not_set_anywhere();
+  }
+  is_utf8_really_inline bool
+  bits_not_set_anywhere(simd16<uint16_t> bits) const {
+    return _mm256_testz_si256(*this, bits);
+  }
+  is_utf8_really_inline bool
+  any_bits_set_anywhere(simd16<uint16_t> bits) const {
+    return !bits_not_set_anywhere(bits);
+  }
+  template <int N> is_utf8_really_inline simd16<uint16_t> shr() const {
+    return simd16<uint16_t>(_mm256_srli_epi16(*this, N));
+  }
+  template <int N> is_utf8_really_inline simd16<uint16_t> shl() const {
+    return simd16<uint16_t>(_mm256_slli_epi16(*this, N));
+  }
+  // Get one of the bits and make a bitmask out of it.
+  // e.g. value.get_bit<7>() gets the high bit
+  template <int N> is_utf8_really_inline int get_bit() const {
+    return _mm256_movemask_epi8(_mm256_slli_epi16(*this, 15 - N));
+  }
+
+  // Change the endianness
+  is_utf8_really_inline simd16<uint16_t> swap_bytes() const {
+    const __m256i swap = _mm256_setr_epi8(
+        1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14, 17, 16, 19, 18,
+        21, 20, 23, 22, 25, 24, 27, 26, 29, 28, 31, 30);
+    return _mm256_shuffle_epi8(*this, swap);
+  }
+
+  // Pack with the unsigned saturation two uint16_t words into single uint8_t
+  // vector
+  static is_utf8_really_inline simd8<uint8_t> pack(const simd16<uint16_t> &v0,
+                                                   const simd16<uint16_t> &v1) {
+    // Note: the AVX2 variant of pack operates on 128-bit lanes, thus
+    //       we have to shuffle lanes in order to produce bytes in the
+    //       correct order.
+
+    // get the 0th lanes
+    const __m128i lo_0 = _mm256_extracti128_si256(v0, 0);
+    const __m128i lo_1 = _mm256_extracti128_si256(v1, 0);
+
+    // get the 1st lanes
+    const __m128i hi_0 = _mm256_extracti128_si256(v0, 1);
+    const __m128i hi_1 = _mm256_extracti128_si256(v1, 1);
+
+    // build new vectors (shuffle lanes)
+    const __m256i t0 = _mm256_set_m128i(lo_1, lo_0);
+    const __m256i t1 = _mm256_set_m128i(hi_1, hi_0);
+
+    // pack words in linear order from v0 and v1
+    return _mm256_packus_epi16(t0, t1);
+  }
+};
+
+template <typename T> struct simd16x32 {
+  static constexpr int NUM_CHUNKS = 64 / sizeof(simd16<T>);
+  static_assert(NUM_CHUNKS == 2,
+                "Haswell kernel should use two registers per 64-byte block.");
+  simd16<T> chunks[NUM_CHUNKS];
+
+  simd16x32(const simd16x32<T> &o) = delete; // no copy allowed
+  simd16x32<T> &
+  operator=(const simd16<T> other) = delete; // no assignment allowed
+  simd16x32() = delete;                      // no default constructor allowed
+
+  is_utf8_really_inline simd16x32(const simd16<T> chunk0,
+                                  const simd16<T> chunk1)
+      : chunks{chunk0, chunk1} {}
+  is_utf8_really_inline simd16x32(const T *ptr)
+      : chunks{simd16<T>::load(ptr),
+               simd16<T>::load(ptr + sizeof(simd16<T>) / sizeof(T))} {}
+
+  is_utf8_really_inline void store(T *ptr) const {
+    this->chunks[0].store(ptr + sizeof(simd16<T>) * 0 / sizeof(T));
+    this->chunks[1].store(ptr + sizeof(simd16<T>) * 1 / sizeof(T));
+  }
+
+  is_utf8_really_inline uint64_t to_bitmask() const {
+    uint64_t r_lo = uint32_t(this->chunks[0].to_bitmask());
+    uint64_t r_hi = this->chunks[1].to_bitmask();
+    return r_lo | (r_hi << 32);
+  }
+
+  is_utf8_really_inline simd16<T> reduce_or() const {
+    return this->chunks[0] | this->chunks[1];
+  }
+
+  is_utf8_really_inline bool is_ascii() const {
+    return this->reduce_or().is_ascii();
+  }
+
+  is_utf8_really_inline void store_ascii_as_utf16(char16_t *ptr) const {
+    this->chunks[0].store_ascii_as_utf16(ptr + sizeof(simd16<T>) * 0);
+    this->chunks[1].store_ascii_as_utf16(ptr + sizeof(simd16<T>));
+  }
+
+  is_utf8_really_inline simd16x32<T> bit_or(const T m) const {
+    const simd16<T> mask = simd16<T>::splat(m);
+    return simd16x32<T>(this->chunks[0] | mask, this->chunks[1] | mask);
+  }
+
+  is_utf8_really_inline void swap_bytes() {
+    this->chunks[0] = this->chunks[0].swap_bytes();
+    this->chunks[1] = this->chunks[1].swap_bytes();
+  }
+
+  is_utf8_really_inline uint64_t eq(const T m) const {
+    const simd16<T> mask = simd16<T>::splat(m);
+    return simd16x32<bool>(this->chunks[0] == mask, this->chunks[1] == mask)
+        .to_bitmask();
+  }
+
+  is_utf8_really_inline uint64_t eq(const simd16x32<uint16_t> &other) const {
+    return simd16x32<bool>(this->chunks[0] == other.chunks[0],
+                           this->chunks[1] == other.chunks[1])
+        .to_bitmask();
+  }
+
+  is_utf8_really_inline uint64_t lteq(const T m) const {
+    const simd16<T> mask = simd16<T>::splat(m);
+    return simd16x32<bool>(this->chunks[0] <= mask, this->chunks[1] <= mask)
+        .to_bitmask();
+  }
+
+  is_utf8_really_inline uint64_t in_range(const T low, const T high) const {
+    const simd16<T> mask_low = simd16<T>::splat(low);
+    const simd16<T> mask_high = simd16<T>::splat(high);
+
+    return simd16x32<bool>(
+               (this->chunks[0] <= mask_high) & (this->chunks[0] >= mask_low),
+               (this->chunks[1] <= mask_high) & (this->chunks[1] >= mask_low),
+               (this->chunks[2] <= mask_high) & (this->chunks[2] >= mask_low),
+               (this->chunks[3] <= mask_high) & (this->chunks[3] >= mask_low))
+        .to_bitmask();
+  }
+  is_utf8_really_inline uint64_t not_in_range(const T low, const T high) const {
+    const simd16<T> mask_low = simd16<T>::splat(static_cast<T>(low - 1));
+    const simd16<T> mask_high = simd16<T>::splat(static_cast<T>(high + 1));
+    return simd16x32<bool>(
+               (this->chunks[0] >= mask_high) | (this->chunks[0] <= mask_low),
+               (this->chunks[1] >= mask_high) | (this->chunks[1] <= mask_low))
+        .to_bitmask();
+  }
+  is_utf8_really_inline uint64_t lt(const T m) const {
+    const simd16<T> mask = simd16<T>::splat(m);
+    return simd16x32<bool>(this->chunks[0] < mask, this->chunks[1] < mask)
+        .to_bitmask();
+  }
+}; // struct simd16x32<T>
+
+} // namespace simd
+
+} // unnamed namespace
+} // namespace haswell
+} // namespace is_utf8_internals
+
+#endif // IS_UTF8_HASWELL_SIMD_H
+
+IS_UTF8_UNTARGET_REGION
+
+#if IS_UTF8_GCC11ORMORE // workaround for
+                        // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=105593
+#pragma GCC diagnostic pop
+#endif // end of workaround
+
+#endif // IS_UTF8_IMPLEMENTATION_HASWELL
+#endif // IS_UTF8_HASWELL_COMMON_H
+
+#ifndef IS_UTF8_WESTMERE_H
+#define IS_UTF8_WESTMERE_H
+
+#ifdef IS_UTF8_FALLBACK_H
+#error "westmere.h must be included before fallback.h"
+#endif
+
+// Default Westmere to on if this is x86-64, unless we'll always select Haswell.
+#ifndef IS_UTF8_IMPLEMENTATION_WESTMERE
+//
+// You do not want to set it to (IS_UTF8_IS_X86_64 && !IS_UTF8_REQUIRES_HASWELL)
+// because you want to rely on runtime dispatch!
+//
+#if IS_UTF8_CAN_ALWAYS_RUN_ICELAKE || IS_UTF8_CAN_ALWAYS_RUN_HASWELL
+#define IS_UTF8_IMPLEMENTATION_WESTMERE 0
+#else
+#define IS_UTF8_IMPLEMENTATION_WESTMERE (IS_UTF8_IS_X86_64)
+#endif
+
+#endif
+
+#define IS_UTF8_CAN_ALWAYS_RUN_WESTMERE                                        \
+  (IS_UTF8_IMPLEMENTATION_WESTMERE && IS_UTF8_IS_X86_64 && __SSE4_2__ &&       \
+   __PCLMUL__)
+
+#if IS_UTF8_IMPLEMENTATION_WESTMERE
+
+#define IS_UTF8_TARGET_WESTMERE IS_UTF8_TARGET_REGION("sse4.2,pclmul")
+
+namespace is_utf8_internals {
+/**
+ * Implementation for Westmere (Intel SSE4.2).
+ */
+namespace westmere {} // namespace westmere
+} // namespace is_utf8_internals
+
+//
+// These two need to be included outside IS_UTF8_TARGET_REGION
+//
+
+#ifndef IS_UTF8_WESTMERE_IMPLEMENTATION_H
+#define IS_UTF8_WESTMERE_IMPLEMENTATION_H
+
+// The constructor may be executed on any host, so we take care not to use
+// IS_UTF8_TARGET_REGION
+namespace is_utf8_internals {
+namespace westmere {
+
+class implementation final : public is_utf8_internals::implementation {
+public:
+  is_utf8_really_inline implementation()
+      : is_utf8_internals::implementation(
+            "westmere", "Intel/AMD SSE4.2",
+            internal::instruction_set::SSE42 |
+                internal::instruction_set::PCLMULQDQ) {}
+  is_utf8_warn_unused bool validate_utf8(const char *buf,
+                                         size_t len) const noexcept final;
+};
+
+} // namespace westmere
+} // namespace is_utf8_internals
+
+#endif // IS_UTF8_WESTMERE_IMPLEMENTATION_H
+
+#ifndef IS_UTF8_WESTMERE_INTRINSICS_H
+#define IS_UTF8_WESTMERE_INTRINSICS_H
+
+#ifdef IS_UTF8_VISUAL_STUDIO
+// under clang within visual studio, this will include <x86intrin.h>
+#include <intrin.h> // visual studio or clang
+#else
+
+#if IS_UTF8_GCC11ORMORE
+// We should not get warnings while including <x86intrin.h> yet we do
+// under some versions of GCC.
+// If the x86intrin.h header has uninitialized values that are problematic,
+// it is a GCC issue, we want to ignore these warnigns.
+IS_UTF8_DISABLE_GCC_WARNING(-Wuninitialized)
+#endif
+
+#include <x86intrin.h> // elsewhere
+
+#if IS_UTF8_GCC11ORMORE
+// cancels the suppression of the -Wuninitialized
+IS_UTF8_POP_DISABLE_WARNINGS
+#endif
+
+#endif // IS_UTF8_VISUAL_STUDIO
+
+#ifdef IS_UTF8_CLANG_VISUAL_STUDIO
+/**
+ * You are not supposed, normally, to include these
+ * headers directly. Instead you should either include intrin.h
+ * or x86intrin.h. However, when compiling with clang
+ * under Windows (i.e., when _MSC_VER is set), these headers
+ * only get included *if* the corresponding features are detected
+ * from macros:
+ */
+#include <smmintrin.h> // for _mm_alignr_epi8
+#include <wmmintrin.h> // for  _mm_clmulepi64_si128
+#endif
+
+#endif // IS_UTF8_WESTMERE_INTRINSICS_H
+
+//
+// The rest need to be inside the region
+//
+
+// redefining IS_UTF8_IMPLEMENTATION to "westmere"
+// #define IS_UTF8_IMPLEMENTATION westmere
+IS_UTF8_TARGET_WESTMERE
+
+// Declarations
+
+#ifndef IS_UTF8_WESTMERE_SIMD_H
+#define IS_UTF8_WESTMERE_SIMD_H
+
+namespace is_utf8_internals {
+namespace westmere {
+namespace {
+namespace simd {
+
+template <typename Child> struct base {
+  __m128i value;
+
+  // Zero constructor
+  is_utf8_really_inline base() : value{__m128i()} {}
+
+  // Conversion from SIMD register
+  is_utf8_really_inline base(const __m128i _value) : value(_value) {}
+  // Conversion to SIMD register
+  is_utf8_really_inline operator const __m128i &() const { return this->value; }
+  is_utf8_really_inline operator __m128i &() { return this->value; }
+  template <endianness big_endian>
+  is_utf8_really_inline void store_ascii_as_utf16(char16_t *p) const {
+    __m128i first = _mm_cvtepu8_epi16(*this);
+    __m128i second = _mm_cvtepu8_epi16(_mm_srli_si128(*this, 8));
+    if (big_endian) {
+      const __m128i swap =
+          _mm_setr_epi8(1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14);
+      first = _mm_shuffle_epi8(first, swap);
+      second = _mm_shuffle_epi8(second, swap);
+    }
+    _mm_storeu_si128(reinterpret_cast<__m128i *>(p), first);
+    _mm_storeu_si128(reinterpret_cast<__m128i *>(p + 8), second);
+  }
+  is_utf8_really_inline void store_ascii_as_utf32(char32_t *p) const {
+    _mm_storeu_si128(reinterpret_cast<__m128i *>(p), _mm_cvtepu8_epi32(*this));
+    _mm_storeu_si128(reinterpret_cast<__m128i *>(p + 4),
+                     _mm_cvtepu8_epi32(_mm_srli_si128(*this, 4)));
+    _mm_storeu_si128(reinterpret_cast<__m128i *>(p + 8),
+                     _mm_cvtepu8_epi32(_mm_srli_si128(*this, 8)));
+    _mm_storeu_si128(reinterpret_cast<__m128i *>(p + 12),
+                     _mm_cvtepu8_epi32(_mm_srli_si128(*this, 12)));
+  }
+  // Bit operations
+  is_utf8_really_inline Child operator|(const Child other) const {
+    return _mm_or_si128(*this, other);
+  }
+  is_utf8_really_inline Child operator&(const Child other) const {
+    return _mm_and_si128(*this, other);
+  }
+  is_utf8_really_inline Child operator^(const Child other) const {
+    return _mm_xor_si128(*this, other);
+  }
+  is_utf8_really_inline Child bit_andnot(const Child other) const {
+    return _mm_andnot_si128(other, *this);
+  }
+  is_utf8_really_inline Child &operator|=(const Child other) {
+    auto this_cast = static_cast<Child *>(this);
+    *this_cast = *this_cast | other;
+    return *this_cast;
+  }
+  is_utf8_really_inline Child &operator&=(const Child other) {
+    auto this_cast = static_cast<Child *>(this);
+    *this_cast = *this_cast & other;
+    return *this_cast;
+  }
+  is_utf8_really_inline Child &operator^=(const Child other) {
+    auto this_cast = static_cast<Child *>(this);
+    *this_cast = *this_cast ^ other;
+    return *this_cast;
+  }
+};
+
+// Forward-declared so they can be used by splat and friends.
+template <typename T> struct simd8;
+
+template <typename T, typename Mask = simd8<bool>>
+struct base8 : base<simd8<T>> {
+  typedef uint16_t bitmask_t;
+  typedef uint32_t bitmask2_t;
+
+  is_utf8_really_inline T first() const { return _mm_extract_epi8(*this, 0); }
+  is_utf8_really_inline T last() const { return _mm_extract_epi8(*this, 15); }
+  is_utf8_really_inline base8() : base<simd8<T>>() {}
+  is_utf8_really_inline base8(const __m128i _value) : base<simd8<T>>(_value) {}
+
+  is_utf8_really_inline Mask operator==(const simd8<T> other) const {
+    return _mm_cmpeq_epi8(*this, other);
+  }
+
+  static const int SIZE = sizeof(base<simd8<T>>::value);
+
+  template <int N = 1>
+  is_utf8_really_inline simd8<T> prev(const simd8<T> prev_chunk) const {
+    return _mm_alignr_epi8(*this, prev_chunk, 16 - N);
+  }
+};
+
+// SIMD byte mask type (returned by things like eq and gt)
+template <> struct simd8<bool> : base8<bool> {
+  static is_utf8_really_inline simd8<bool> splat(bool _value) {
+    return _mm_set1_epi8(uint8_t(-(!!_value)));
+  }
+
+  is_utf8_really_inline simd8<bool>() : base8() {}
+  is_utf8_really_inline simd8<bool>(const __m128i _value)
+      : base8<bool>(_value) {}
+  // Splat constructor
+  is_utf8_really_inline simd8<bool>(bool _value) : base8<bool>(splat(_value)) {}
+
+  is_utf8_really_inline int to_bitmask() const {
+    return _mm_movemask_epi8(*this);
+  }
+  is_utf8_really_inline bool any() const {
+    return !_mm_testz_si128(*this, *this);
+  }
+  is_utf8_really_inline bool none() const {
+    return _mm_testz_si128(*this, *this);
+  }
+  is_utf8_really_inline bool all() const {
+    return _mm_movemask_epi8(*this) == 0xFFFF;
+  }
+  is_utf8_really_inline simd8<bool> operator~() const { return *this ^ true; }
+};
+
+template <typename T> struct base8_numeric : base8<T> {
+  static is_utf8_really_inline simd8<T> splat(T _value) {
+    return _mm_set1_epi8(_value);
+  }
+  static is_utf8_really_inline simd8<T> zero() { return _mm_setzero_si128(); }
+  static is_utf8_really_inline simd8<T> load(const T values[16]) {
+    return _mm_loadu_si128(reinterpret_cast<const __m128i *>(values));
+  }
+  // Repeat 16 values as many times as necessary (usually for lookup tables)
+  static is_utf8_really_inline simd8<T> repeat_16(T v0, T v1, T v2, T v3, T v4,
+                                                  T v5, T v6, T v7, T v8, T v9,
+                                                  T v10, T v11, T v12, T v13,
+                                                  T v14, T v15) {
+    return simd8<T>(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13,
+                    v14, v15);
+  }
+
+  is_utf8_really_inline base8_numeric() : base8<T>() {}
+  is_utf8_really_inline base8_numeric(const __m128i _value)
+      : base8<T>(_value) {}
+
+  // Store to array
+  is_utf8_really_inline void store(T dst[16]) const {
+    return _mm_storeu_si128(reinterpret_cast<__m128i *>(dst), *this);
+  }
+
+  // Override to distinguish from bool version
+  is_utf8_really_inline simd8<T> operator~() const { return *this ^ 0xFFu; }
+
+  // Addition/subtraction are the same for signed and unsigned
+  is_utf8_really_inline simd8<T> operator+(const simd8<T> other) const {
+    return _mm_add_epi8(*this, other);
+  }
+  is_utf8_really_inline simd8<T> operator-(const simd8<T> other) const {
+    return _mm_sub_epi8(*this, other);
+  }
+  is_utf8_really_inline simd8<T> &operator+=(const simd8<T> other) {
+    *this = *this + other;
+    return *static_cast<simd8<T> *>(this);
+  }
+  is_utf8_really_inline simd8<T> &operator-=(const simd8<T> other) {
+    *this = *this - other;
+    return *static_cast<simd8<T> *>(this);
+  }
+
+  // Perform a lookup assuming the value is between 0 and 16 (undefined behavior
+  // for out of range values)
+  template <typename L>
+  is_utf8_really_inline simd8<L> lookup_16(simd8<L> lookup_table) const {
+    return _mm_shuffle_epi8(lookup_table, *this);
+  }
+
+  template <typename L>
+  is_utf8_really_inline simd8<L>
+  lookup_16(L replace0, L replace1, L replace2, L replace3, L replace4,
+            L replace5, L replace6, L replace7, L replace8, L replace9,
+            L replace10, L replace11, L replace12, L replace13, L replace14,
+            L replace15) const {
+    return lookup_16(simd8<L>::repeat_16(
+        replace0, replace1, replace2, replace3, replace4, replace5, replace6,
+        replace7, replace8, replace9, replace10, replace11, replace12,
+        replace13, replace14, replace15));
+  }
+};
+
+// Signed bytes
+template <> struct simd8<int8_t> : base8_numeric<int8_t> {
+  is_utf8_really_inline simd8() : base8_numeric<int8_t>() {}
+  is_utf8_really_inline simd8(const __m128i _value)
+      : base8_numeric<int8_t>(_value) {}
+  // Splat constructor
+  is_utf8_really_inline simd8(int8_t _value) : simd8(splat(_value)) {}
+  // Array constructor
+  is_utf8_really_inline simd8(const int8_t *values) : simd8(load(values)) {}
+  // Member-by-member initialization
+  is_utf8_really_inline simd8(int8_t v0, int8_t v1, int8_t v2, int8_t v3,
+                              int8_t v4, int8_t v5, int8_t v6, int8_t v7,
+                              int8_t v8, int8_t v9, int8_t v10, int8_t v11,
+                              int8_t v12, int8_t v13, int8_t v14, int8_t v15)
+      : simd8(_mm_setr_epi8(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11,
+                            v12, v13, v14, v15)) {}
+  // Repeat 16 values as many times as necessary (usually for lookup tables)
+  is_utf8_really_inline static simd8<int8_t>
+  repeat_16(int8_t v0, int8_t v1, int8_t v2, int8_t v3, int8_t v4, int8_t v5,
+            int8_t v6, int8_t v7, int8_t v8, int8_t v9, int8_t v10, int8_t v11,
+            int8_t v12, int8_t v13, int8_t v14, int8_t v15) {
+    return simd8<int8_t>(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12,
+                         v13, v14, v15);
+  }
+  is_utf8_really_inline operator simd8<uint8_t>() const;
+  is_utf8_really_inline bool is_ascii() const {
+    return _mm_movemask_epi8(*this) == 0;
+  }
+
+  // Order-sensitive comparisons
+  is_utf8_really_inline simd8<int8_t> max_val(const simd8<int8_t> other) const {
+    return _mm_max_epi8(*this, other);
+  }
+  is_utf8_really_inline simd8<int8_t> min_val(const simd8<int8_t> other) const {
+    return _mm_min_epi8(*this, other);
+  }
+  is_utf8_really_inline simd8<bool> operator>(const simd8<int8_t> other) const {
+    return _mm_cmpgt_epi8(*this, other);
+  }
+  is_utf8_really_inline simd8<bool> operator<(const simd8<int8_t> other) const {
+    return _mm_cmpgt_epi8(other, *this);
+  }
+};
+
+// Unsigned bytes
+template <> struct simd8<uint8_t> : base8_numeric<uint8_t> {
+  is_utf8_really_inline simd8() : base8_numeric<uint8_t>() {}
+  is_utf8_really_inline simd8(const __m128i _value)
+      : base8_numeric<uint8_t>(_value) {}
+
+  // Splat constructor
+  is_utf8_really_inline simd8(uint8_t _value) : simd8(splat(_value)) {}
+  // Array constructor
+  is_utf8_really_inline simd8(const uint8_t *values) : simd8(load(values)) {}
+  // Member-by-member initialization
+  is_utf8_really_inline
+  simd8(uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3, uint8_t v4, uint8_t v5,
+        uint8_t v6, uint8_t v7, uint8_t v8, uint8_t v9, uint8_t v10,
+        uint8_t v11, uint8_t v12, uint8_t v13, uint8_t v14, uint8_t v15)
+      : simd8(_mm_setr_epi8(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11,
+                            v12, v13, v14, v15)) {}
+  // Repeat 16 values as many times as necessary (usually for lookup tables)
+  is_utf8_really_inline static simd8<uint8_t>
+  repeat_16(uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3, uint8_t v4,
+            uint8_t v5, uint8_t v6, uint8_t v7, uint8_t v8, uint8_t v9,
+            uint8_t v10, uint8_t v11, uint8_t v12, uint8_t v13, uint8_t v14,
+            uint8_t v15) {
+    return simd8<uint8_t>(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12,
+                          v13, v14, v15);
+  }
+
+  // Saturated math
+  is_utf8_really_inline simd8<uint8_t>
+  saturating_add(const simd8<uint8_t> other) const {
+    return _mm_adds_epu8(*this, other);
+  }
+  is_utf8_really_inline simd8<uint8_t>
+  saturating_sub(const simd8<uint8_t> other) const {
+    return _mm_subs_epu8(*this, other);
+  }
+
+  // Order-specific operations
+  is_utf8_really_inline simd8<uint8_t>
+  max_val(const simd8<uint8_t> other) const {
+    return _mm_max_epu8(*this, other);
+  }
+  is_utf8_really_inline simd8<uint8_t>
+  min_val(const simd8<uint8_t> other) const {
+    return _mm_min_epu8(*this, other);
+  }
+  // Same as >, but only guarantees true is nonzero (< guarantees true = -1)
+  is_utf8_really_inline simd8<uint8_t>
+  gt_bits(const simd8<uint8_t> other) const {
+    return this->saturating_sub(other);
+  }
+  // Same as <, but only guarantees true is nonzero (< guarantees true = -1)
+  is_utf8_really_inline simd8<uint8_t>
+  lt_bits(const simd8<uint8_t> other) const {
+    return other.saturating_sub(*this);
+  }
+  is_utf8_really_inline simd8<bool>
+  operator<=(const simd8<uint8_t> other) const {
+    return other.max_val(*this) == other;
+  }
+  is_utf8_really_inline simd8<bool>
+  operator>=(const simd8<uint8_t> other) const {
+    return other.min_val(*this) == other;
+  }
+  is_utf8_really_inline simd8<bool>
+  operator>(const simd8<uint8_t> other) const {
+    return this->gt_bits(other).any_bits_set();
+  }
+  is_utf8_really_inline simd8<bool>
+  operator<(const simd8<uint8_t> other) const {
+    return this->gt_bits(other).any_bits_set();
+  }
+
+  // Bit-specific operations
+  is_utf8_really_inline simd8<bool> bits_not_set() const {
+    return *this == uint8_t(0);
+  }
+  is_utf8_really_inline simd8<bool> bits_not_set(simd8<uint8_t> bits) const {
+    return (*this & bits).bits_not_set();
+  }
+  is_utf8_really_inline simd8<bool> any_bits_set() const {
+    return ~this->bits_not_set();
+  }
+  is_utf8_really_inline simd8<bool> any_bits_set(simd8<uint8_t> bits) const {
+    return ~this->bits_not_set(bits);
+  }
+  is_utf8_really_inline bool is_ascii() const {
+    return _mm_movemask_epi8(*this) == 0;
+  }
+
+  is_utf8_really_inline bool bits_not_set_anywhere() const {
+    return _mm_testz_si128(*this, *this);
+  }
+  is_utf8_really_inline bool any_bits_set_anywhere() const {
+    return !bits_not_set_anywhere();
+  }
+  is_utf8_really_inline bool bits_not_set_anywhere(simd8<uint8_t> bits) const {
+    return _mm_testz_si128(*this, bits);
+  }
+  is_utf8_really_inline bool any_bits_set_anywhere(simd8<uint8_t> bits) const {
+    return !bits_not_set_anywhere(bits);
+  }
+  template <int N> is_utf8_really_inline simd8<uint8_t> shr() const {
+    return simd8<uint8_t>(_mm_srli_epi16(*this, N)) & uint8_t(0xFFu >> N);
+  }
+  template <int N> is_utf8_really_inline simd8<uint8_t> shl() const {
+    return simd8<uint8_t>(_mm_slli_epi16(*this, N)) & uint8_t(0xFFu << N);
+  }
+  // Get one of the bits and make a bitmask out of it.
+  // e.g. value.get_bit<7>() gets the high bit
+  template <int N> is_utf8_really_inline int get_bit() const {
+    return _mm_movemask_epi8(_mm_slli_epi16(*this, 7 - N));
+  }
+};
+is_utf8_really_inline simd8<int8_t>::operator simd8<uint8_t>() const {
+  return this->value;
+}
+
+// Unsigned bytes
+template <> struct simd8<uint16_t> : base<uint16_t> {
+  static is_utf8_really_inline simd8<uint16_t> splat(uint16_t _value) {
+    return _mm_set1_epi16(_value);
+  }
+  static is_utf8_really_inline simd8<uint16_t> load(const uint16_t values[8]) {
+    return _mm_loadu_si128(reinterpret_cast<const __m128i *>(values));
+  }
+
+  is_utf8_really_inline simd8() : base<uint16_t>() {}
+  is_utf8_really_inline simd8(const __m128i _value) : base<uint16_t>(_value) {}
+  // Splat constructor
+  is_utf8_really_inline simd8(uint16_t _value) : simd8(splat(_value)) {}
+  // Array constructor
+  is_utf8_really_inline simd8(const uint16_t *values) : simd8(load(values)) {}
+  // Member-by-member initialization
+  is_utf8_really_inline simd8(uint16_t v0, uint16_t v1, uint16_t v2,
+                              uint16_t v3, uint16_t v4, uint16_t v5,
+                              uint16_t v6, uint16_t v7)
+      : simd8(_mm_setr_epi16(v0, v1, v2, v3, v4, v5, v6, v7)) {}
+
+  // Saturated math
+  is_utf8_really_inline simd8<uint16_t>
+  saturating_add(const simd8<uint16_t> other) const {
+    return _mm_adds_epu16(*this, other);
+  }
+  is_utf8_really_inline simd8<uint16_t>
+  saturating_sub(const simd8<uint16_t> other) const {
+    return _mm_subs_epu16(*this, other);
+  }
+
+  // Order-specific operations
+  is_utf8_really_inline simd8<uint16_t>
+  max_val(const simd8<uint16_t> other) const {
+    return _mm_max_epu16(*this, other);
+  }
+  is_utf8_really_inline simd8<uint16_t>
+  min_val(const simd8<uint16_t> other) const {
+    return _mm_min_epu16(*this, other);
+  }
+  // Same as >, but only guarantees true is nonzero (< guarantees true = -1)
+  is_utf8_really_inline simd8<uint16_t>
+  gt_bits(const simd8<uint16_t> other) const {
+    return this->saturating_sub(other);
+  }
+  // Same as <, but only guarantees true is nonzero (< guarantees true = -1)
+  is_utf8_really_inline simd8<uint16_t>
+  lt_bits(const simd8<uint16_t> other) const {
+    return other.saturating_sub(*this);
+  }
+  is_utf8_really_inline simd8<bool>
+  operator<=(const simd8<uint16_t> other) const {
+    return other.max_val(*this) == other;
+  }
+  is_utf8_really_inline simd8<bool>
+  operator>=(const simd8<uint16_t> other) const {
+    return other.min_val(*this) == other;
+  }
+  is_utf8_really_inline simd8<bool>
+  operator==(const simd8<uint16_t> other) const {
+    return _mm_cmpeq_epi16(*this, other);
+  }
+  is_utf8_really_inline simd8<bool>
+  operator&(const simd8<uint16_t> other) const {
+    return _mm_and_si128(*this, other);
+  }
+  is_utf8_really_inline simd8<bool>
+  operator|(const simd8<uint16_t> other) const {
+    return _mm_or_si128(*this, other);
+  }
+
+  // Bit-specific operations
+  is_utf8_really_inline simd8<bool> bits_not_set() const {
+    return *this == uint16_t(0);
+  }
+  is_utf8_really_inline simd8<bool> any_bits_set() const {
+    return ~this->bits_not_set();
+  }
+
+  is_utf8_really_inline bool bits_not_set_anywhere() const {
+    return _mm_testz_si128(*this, *this);
+  }
+  is_utf8_really_inline bool any_bits_set_anywhere() const {
+    return !bits_not_set_anywhere();
+  }
+  is_utf8_really_inline bool bits_not_set_anywhere(simd8<uint16_t> bits) const {
+    return _mm_testz_si128(*this, bits);
+  }
+  is_utf8_really_inline bool any_bits_set_anywhere(simd8<uint16_t> bits) const {
+    return !bits_not_set_anywhere(bits);
+  }
+};
+template <typename T> struct simd8x64 {
+  static constexpr int NUM_CHUNKS = 64 / sizeof(simd8<T>);
+  static_assert(NUM_CHUNKS == 4,
+                "Westmere kernel should use four registers per 64-byte block.");
+  simd8<T> chunks[NUM_CHUNKS];
+
+  simd8x64(const simd8x64<T> &o) = delete; // no copy allowed
+  simd8x64<T> &
+  operator=(const simd8<T> other) = delete; // no assignment allowed
+  simd8x64() = delete;                      // no default constructor allowed
+
+  is_utf8_really_inline simd8x64(const simd8<T> chunk0, const simd8<T> chunk1,
+                                 const simd8<T> chunk2, const simd8<T> chunk3)
+      : chunks{chunk0, chunk1, chunk2, chunk3} {}
+  is_utf8_really_inline simd8x64(const T *ptr)
+      : chunks{simd8<T>::load(ptr),
+               simd8<T>::load(ptr + sizeof(simd8<T>) / sizeof(T)),
+               simd8<T>::load(ptr + 2 * sizeof(simd8<T>) / sizeof(T)),
+               simd8<T>::load(ptr + 3 * sizeof(simd8<T>) / sizeof(T))} {}
+
+  is_utf8_really_inline void store(T *ptr) const {
+    this->chunks[0].store(ptr + sizeof(simd8<T>) * 0 / sizeof(T));
+    this->chunks[1].store(ptr + sizeof(simd8<T>) * 1 / sizeof(T));
+    this->chunks[2].store(ptr + sizeof(simd8<T>) * 2 / sizeof(T));
+    this->chunks[3].store(ptr + sizeof(simd8<T>) * 3 / sizeof(T));
+  }
+
+  is_utf8_really_inline simd8x64<T> &operator|=(const simd8x64<T> &other) {
+    this->chunks[0] |= other.chunks[0];
+    this->chunks[1] |= other.chunks[1];
+    this->chunks[2] |= other.chunks[2];
+    this->chunks[3] |= other.chunks[3];
+    return *this;
+  }
+
+  is_utf8_really_inline simd8<T> reduce_or() const {
+    return (this->chunks[0] | this->chunks[1]) |
+           (this->chunks[2] | this->chunks[3]);
+  }
+
+  is_utf8_really_inline bool is_ascii() const {
+    return this->reduce_or().is_ascii();
+  }
+
+  template <endianness endian>
+  is_utf8_really_inline void store_ascii_as_utf16(char16_t *ptr) const {
+    this->chunks[0].template store_ascii_as_utf16<endian>(ptr +
+                                                          sizeof(simd8<T>) * 0);
+    this->chunks[1].template store_ascii_as_utf16<endian>(ptr +
+                                                          sizeof(simd8<T>) * 1);
+    this->chunks[2].template store_ascii_as_utf16<endian>(ptr +
+                                                          sizeof(simd8<T>) * 2);
+    this->chunks[3].template store_ascii_as_utf16<endian>(ptr +
+                                                          sizeof(simd8<T>) * 3);
+  }
+
+  is_utf8_really_inline void store_ascii_as_utf32(char32_t *ptr) const {
+    this->chunks[0].store_ascii_as_utf32(ptr + sizeof(simd8<T>) * 0);
+    this->chunks[1].store_ascii_as_utf32(ptr + sizeof(simd8<T>) * 1);
+    this->chunks[2].store_ascii_as_utf32(ptr + sizeof(simd8<T>) * 2);
+    this->chunks[3].store_ascii_as_utf32(ptr + sizeof(simd8<T>) * 3);
+  }
+
+  is_utf8_really_inline uint64_t to_bitmask() const {
+    uint64_t r0 = uint32_t(this->chunks[0].to_bitmask());
+    uint64_t r1 = this->chunks[1].to_bitmask();
+    uint64_t r2 = this->chunks[2].to_bitmask();
+    uint64_t r3 = this->chunks[3].to_bitmask();
+    return r0 | (r1 << 16) | (r2 << 32) | (r3 << 48);
+  }
+
+  is_utf8_really_inline uint64_t eq(const T m) const {
+    const simd8<T> mask = simd8<T>::splat(m);
+    return simd8x64<bool>(this->chunks[0] == mask, this->chunks[1] == mask,
+                          this->chunks[2] == mask, this->chunks[3] == mask)
+        .to_bitmask();
+  }
+
+  is_utf8_really_inline uint64_t eq(const simd8x64<uint8_t> &other) const {
+    return simd8x64<bool>(this->chunks[0] == other.chunks[0],
+                          this->chunks[1] == other.chunks[1],
+                          this->chunks[2] == other.chunks[2],
+                          this->chunks[3] == other.chunks[3])
+        .to_bitmask();
+  }
+
+  is_utf8_really_inline uint64_t lteq(const T m) const {
+    const simd8<T> mask = simd8<T>::splat(m);
+    return simd8x64<bool>(this->chunks[0] <= mask, this->chunks[1] <= mask,
+                          this->chunks[2] <= mask, this->chunks[3] <= mask)
+        .to_bitmask();
+  }
+
+  is_utf8_really_inline uint64_t in_range(const T low, const T high) const {
+    const simd8<T> mask_low = simd8<T>::splat(low);
+    const simd8<T> mask_high = simd8<T>::splat(high);
+
+    return simd8x64<bool>(
+               (this->chunks[0] <= mask_high) & (this->chunks[0] >= mask_low),
+               (this->chunks[1] <= mask_high) & (this->chunks[1] >= mask_low),
+               (this->chunks[2] <= mask_high) & (this->chunks[2] >= mask_low),
+               (this->chunks[3] <= mask_high) & (this->chunks[3] >= mask_low))
+        .to_bitmask();
+  }
+  is_utf8_really_inline uint64_t not_in_range(const T low, const T high) const {
+    const simd8<T> mask_low = simd8<T>::splat(low - 1);
+    const simd8<T> mask_high = simd8<T>::splat(high + 1);
+    return simd8x64<bool>(
+               (this->chunks[0] >= mask_high) | (this->chunks[0] <= mask_low),
+               (this->chunks[1] >= mask_high) | (this->chunks[1] <= mask_low),
+               (this->chunks[2] >= mask_high) | (this->chunks[2] <= mask_low),
+               (this->chunks[3] >= mask_high) | (this->chunks[3] <= mask_low))
+        .to_bitmask();
+  }
+  is_utf8_really_inline uint64_t lt(const T m) const {
+    const simd8<T> mask = simd8<T>::splat(m);
+    return simd8x64<bool>(this->chunks[0] < mask, this->chunks[1] < mask,
+                          this->chunks[2] < mask, this->chunks[3] < mask)
+        .to_bitmask();
+  }
+
+  is_utf8_really_inline uint64_t gt(const T m) const {
+    const simd8<T> mask = simd8<T>::splat(m);
+    return simd8x64<bool>(this->chunks[0] > mask, this->chunks[1] > mask,
+                          this->chunks[2] > mask, this->chunks[3] > mask)
+        .to_bitmask();
+  }
+  is_utf8_really_inline uint64_t gteq(const T m) const {
+    const simd8<T> mask = simd8<T>::splat(m);
+    return simd8x64<bool>(this->chunks[0] >= mask, this->chunks[1] >= mask,
+                          this->chunks[2] >= mask, this->chunks[3] >= mask)
+        .to_bitmask();
+  }
+  is_utf8_really_inline uint64_t gteq_unsigned(const uint8_t m) const {
+    const simd8<uint8_t> mask = simd8<uint8_t>::splat(m);
+    return simd8x64<bool>(simd8<uint8_t>(__m128i(this->chunks[0])) >= mask,
+                          simd8<uint8_t>(__m128i(this->chunks[1])) >= mask,
+                          simd8<uint8_t>(__m128i(this->chunks[2])) >= mask,
+                          simd8<uint8_t>(__m128i(this->chunks[3])) >= mask)
+        .to_bitmask();
+  }
+}; // struct simd8x64<T>
+
+template <typename T> struct simd16;
+
+template <typename T, typename Mask = simd16<bool>>
+struct base16 : base<simd16<T>> {
+  typedef uint16_t bitmask_t;
+  typedef uint32_t bitmask2_t;
+
+  is_utf8_really_inline base16() : base<simd16<T>>() {}
+  is_utf8_really_inline base16(const __m128i _value)
+      : base<simd16<T>>(_value) {}
+  template <typename Pointer>
+  is_utf8_really_inline base16(const Pointer *ptr)
+      : base16(_mm_loadu_si128(reinterpret_cast<const __m128i *>(ptr))) {}
+
+  is_utf8_really_inline Mask operator==(const simd16<T> other) const {
+    return _mm_cmpeq_epi16(*this, other);
+  }
+
+  static const int SIZE = sizeof(base<simd16<T>>::value);
+
+  template <int N = 1>
+  is_utf8_really_inline simd16<T> prev(const simd16<T> prev_chunk) const {
+    return _mm_alignr_epi8(*this, prev_chunk, 16 - N);
+  }
+};
+
+// SIMD byte mask type (returned by things like eq and gt)
+template <> struct simd16<bool> : base16<bool> {
+  static is_utf8_really_inline simd16<bool> splat(bool _value) {
+    return _mm_set1_epi16(uint16_t(-(!!_value)));
+  }
+
+  is_utf8_really_inline simd16<bool>() : base16() {}
+  is_utf8_really_inline simd16<bool>(const __m128i _value)
+      : base16<bool>(_value) {}
+  // Splat constructor
+  is_utf8_really_inline simd16<bool>(bool _value)
+      : base16<bool>(splat(_value)) {}
+
+  is_utf8_really_inline int to_bitmask() const {
+    return _mm_movemask_epi8(*this);
+  }
+  is_utf8_really_inline bool any() const {
+    return !_mm_testz_si128(*this, *this);
+  }
+  is_utf8_really_inline simd16<bool> operator~() const { return *this ^ true; }
+};
+
+template <typename T> struct base16_numeric : base16<T> {
+  static is_utf8_really_inline simd16<T> splat(T _value) {
+    return _mm_set1_epi16(_value);
+  }
+  static is_utf8_really_inline simd16<T> zero() { return _mm_setzero_si128(); }
+  static is_utf8_really_inline simd16<T> load(const T values[8]) {
+    return _mm_loadu_si128(reinterpret_cast<const __m128i *>(values));
+  }
+
+  is_utf8_really_inline base16_numeric() : base16<T>() {}
+  is_utf8_really_inline base16_numeric(const __m128i _value)
+      : base16<T>(_value) {}
+
+  // Store to array
+  is_utf8_really_inline void store(T dst[8]) const {
+    return _mm_storeu_si128(reinterpret_cast<__m128i *>(dst), *this);
+  }
+
+  // Override to distinguish from bool version
+  is_utf8_really_inline simd16<T> operator~() const { return *this ^ 0xFFu; }
+
+  // Addition/subtraction are the same for signed and unsigned
+  is_utf8_really_inline simd16<T> operator+(const simd16<T> other) const {
+    return _mm_add_epi16(*this, other);
+  }
+  is_utf8_really_inline simd16<T> operator-(const simd16<T> other) const {
+    return _mm_sub_epi16(*this, other);
+  }
+  is_utf8_really_inline simd16<T> &operator+=(const simd16<T> other) {
+    *this = *this + other;
+    return *static_cast<simd16<T> *>(this);
+  }
+  is_utf8_really_inline simd16<T> &operator-=(const simd16<T> other) {
+    *this = *this - other;
+    return *static_cast<simd16<T> *>(this);
+  }
+};
+
+// Signed words
+template <> struct simd16<int16_t> : base16_numeric<int16_t> {
+  is_utf8_really_inline simd16() : base16_numeric<int16_t>() {}
+  is_utf8_really_inline simd16(const __m128i _value)
+      : base16_numeric<int16_t>(_value) {}
+  // Splat constructor
+  is_utf8_really_inline simd16(int16_t _value) : simd16(splat(_value)) {}
+  // Array constructor
+  is_utf8_really_inline simd16(const int16_t *values) : simd16(load(values)) {}
+  is_utf8_really_inline simd16(const char16_t *values)
+      : simd16(load(reinterpret_cast<const int16_t *>(values))) {}
+  // Member-by-member initialization
+  is_utf8_really_inline simd16(int16_t v0, int16_t v1, int16_t v2, int16_t v3,
+                               int16_t v4, int16_t v5, int16_t v6, int16_t v7)
+      : simd16(_mm_setr_epi16(v0, v1, v2, v3, v4, v5, v6, v7)) {}
+  is_utf8_really_inline operator simd16<uint16_t>() const;
+
+  // Order-sensitive comparisons
+  is_utf8_really_inline simd16<int16_t>
+  max_val(const simd16<int16_t> other) const {
+    return _mm_max_epi16(*this, other);
+  }
+  is_utf8_really_inline simd16<int16_t>
+  min_val(const simd16<int16_t> other) const {
+    return _mm_min_epi16(*this, other);
+  }
+  is_utf8_really_inline simd16<bool>
+  operator>(const simd16<int16_t> other) const {
+    return _mm_cmpgt_epi16(*this, other);
+  }
+  is_utf8_really_inline simd16<bool>
+  operator<(const simd16<int16_t> other) const {
+    return _mm_cmpgt_epi16(other, *this);
+  }
+};
+
+// Unsigned words
+template <> struct simd16<uint16_t> : base16_numeric<uint16_t> {
+  is_utf8_really_inline simd16() : base16_numeric<uint16_t>() {}
+  is_utf8_really_inline simd16(const __m128i _value)
+      : base16_numeric<uint16_t>(_value) {}
+
+  // Splat constructor
+  is_utf8_really_inline simd16(uint16_t _value) : simd16(splat(_value)) {}
+  // Array constructor
+  is_utf8_really_inline simd16(const uint16_t *values) : simd16(load(values)) {}
+  is_utf8_really_inline simd16(const char16_t *values)
+      : simd16(load(reinterpret_cast<const uint16_t *>(values))) {}
+  // Member-by-member initialization
+  is_utf8_really_inline simd16(uint16_t v0, uint16_t v1, uint16_t v2,
+                               uint16_t v3, uint16_t v4, uint16_t v5,
+                               uint16_t v6, uint16_t v7)
+      : simd16(_mm_setr_epi16(v0, v1, v2, v3, v4, v5, v6, v7)) {}
+  // Repeat 16 values as many times as necessary (usually for lookup tables)
+  is_utf8_really_inline static simd16<uint16_t>
+  repeat_16(uint16_t v0, uint16_t v1, uint16_t v2, uint16_t v3, uint16_t v4,
+            uint16_t v5, uint16_t v6, uint16_t v7) {
+    return simd16<uint16_t>(v0, v1, v2, v3, v4, v5, v6, v7);
+  }
+
+  // Saturated math
+  is_utf8_really_inline simd16<uint16_t>
+  saturating_add(const simd16<uint16_t> other) const {
+    return _mm_adds_epu16(*this, other);
+  }
+  is_utf8_really_inline simd16<uint16_t>
+  saturating_sub(const simd16<uint16_t> other) const {
+    return _mm_subs_epu16(*this, other);
+  }
+
+  // Order-specific operations
+  is_utf8_really_inline simd16<uint16_t>
+  max_val(const simd16<uint16_t> other) const {
+    return _mm_max_epu16(*this, other);
+  }
+  is_utf8_really_inline simd16<uint16_t>
+  min_val(const simd16<uint16_t> other) const {
+    return _mm_min_epu16(*this, other);
+  }
+  // Same as >, but only guarantees true is nonzero (< guarantees true = -1)
+  is_utf8_really_inline simd16<uint16_t>
+  gt_bits(const simd16<uint16_t> other) const {
+    return this->saturating_sub(other);
+  }
+  // Same as <, but only guarantees true is nonzero (< guarantees true = -1)
+  is_utf8_really_inline simd16<uint16_t>
+  lt_bits(const simd16<uint16_t> other) const {
+    return other.saturating_sub(*this);
+  }
+  is_utf8_really_inline simd16<bool>
+  operator<=(const simd16<uint16_t> other) const {
+    return other.max_val(*this) == other;
+  }
+  is_utf8_really_inline simd16<bool>
+  operator>=(const simd16<uint16_t> other) const {
+    return other.min_val(*this) == other;
+  }
+  is_utf8_really_inline simd16<bool>
+  operator>(const simd16<uint16_t> other) const {
+    return this->gt_bits(other).any_bits_set();
+  }
+  is_utf8_really_inline simd16<bool>
+  operator<(const simd16<uint16_t> other) const {
+    return this->gt_bits(other).any_bits_set();
+  }
+
+  // Bit-specific operations
+  is_utf8_really_inline simd16<bool> bits_not_set() const {
+    return *this == uint16_t(0);
+  }
+  is_utf8_really_inline simd16<bool> bits_not_set(simd16<uint16_t> bits) const {
+    return (*this & bits).bits_not_set();
+  }
+  is_utf8_really_inline simd16<bool> any_bits_set() const {
+    return ~this->bits_not_set();
+  }
+  is_utf8_really_inline simd16<bool> any_bits_set(simd16<uint16_t> bits) const {
+    return ~this->bits_not_set(bits);
+  }
+
+  is_utf8_really_inline bool bits_not_set_anywhere() const {
+    return _mm_testz_si128(*this, *this);
+  }
+  is_utf8_really_inline bool any_bits_set_anywhere() const {
+    return !bits_not_set_anywhere();
+  }
+  is_utf8_really_inline bool
+  bits_not_set_anywhere(simd16<uint16_t> bits) const {
+    return _mm_testz_si128(*this, bits);
+  }
+  is_utf8_really_inline bool
+  any_bits_set_anywhere(simd16<uint16_t> bits) const {
+    return !bits_not_set_anywhere(bits);
+  }
+  template <int N> is_utf8_really_inline simd16<uint16_t> shr() const {
+    return simd16<uint16_t>(_mm_srli_epi16(*this, N));
+  }
+  template <int N> is_utf8_really_inline simd16<uint16_t> shl() const {
+    return simd16<uint16_t>(_mm_slli_epi16(*this, N));
+  }
+  // Get one of the bits and make a bitmask out of it.
+  // e.g. value.get_bit<7>() gets the high bit
+  template <int N> is_utf8_really_inline int get_bit() const {
+    return _mm_movemask_epi8(_mm_slli_epi16(*this, 7 - N));
+  }
+
+  // Change the endianness
+  is_utf8_really_inline simd16<uint16_t> swap_bytes() const {
+    const __m128i swap =
+        _mm_setr_epi8(1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14);
+    return _mm_shuffle_epi8(*this, swap);
+  }
+
+  // Pack with the unsigned saturation  two uint16_t words into single uint8_t
+  // vector
+  static is_utf8_really_inline simd8<uint8_t> pack(const simd16<uint16_t> &v0,
+                                                   const simd16<uint16_t> &v1) {
+    return _mm_packus_epi16(v0, v1);
+  }
+};
+is_utf8_really_inline simd16<int16_t>::operator simd16<uint16_t>() const {
+  return this->value;
+}
+
+template <typename T> struct simd16x32 {
+  static constexpr int NUM_CHUNKS = 64 / sizeof(simd16<T>);
+  static_assert(NUM_CHUNKS == 4,
+                "Westmere kernel should use four registers per 64-byte block.");
+  simd16<T> chunks[NUM_CHUNKS];
+
+  simd16x32(const simd16x32<T> &o) = delete; // no copy allowed
+  simd16x32<T> &
+  operator=(const simd16<T> other) = delete; // no assignment allowed
+  simd16x32() = delete;                      // no default constructor allowed
+
+  is_utf8_really_inline
+  simd16x32(const simd16<T> chunk0, const simd16<T> chunk1,
+            const simd16<T> chunk2, const simd16<T> chunk3)
+      : chunks{chunk0, chunk1, chunk2, chunk3} {}
+  is_utf8_really_inline simd16x32(const T *ptr)
+      : chunks{simd16<T>::load(ptr),
+               simd16<T>::load(ptr + sizeof(simd16<T>) / sizeof(T)),
+               simd16<T>::load(ptr + 2 * sizeof(simd16<T>) / sizeof(T)),
+               simd16<T>::load(ptr + 3 * sizeof(simd16<T>) / sizeof(T))} {}
+
+  is_utf8_really_inline void store(T *ptr) const {
+    this->chunks[0].store(ptr + sizeof(simd16<T>) * 0 / sizeof(T));
+    this->chunks[1].store(ptr + sizeof(simd16<T>) * 1 / sizeof(T));
+    this->chunks[2].store(ptr + sizeof(simd16<T>) * 2 / sizeof(T));
+    this->chunks[3].store(ptr + sizeof(simd16<T>) * 3 / sizeof(T));
+  }
+
+  is_utf8_really_inline simd16<T> reduce_or() const {
+    return (this->chunks[0] | this->chunks[1]) |
+           (this->chunks[2] | this->chunks[3]);
+  }
+
+  is_utf8_really_inline bool is_ascii() const {
+    return this->reduce_or().is_ascii();
+  }
+
+  is_utf8_really_inline void store_ascii_as_utf16(char16_t *ptr) const {
+    this->chunks[0].store_ascii_as_utf16(ptr + sizeof(simd16<T>) * 0);
+    this->chunks[1].store_ascii_as_utf16(ptr + sizeof(simd16<T>) * 1);
+    this->chunks[2].store_ascii_as_utf16(ptr + sizeof(simd16<T>) * 2);
+    this->chunks[3].store_ascii_as_utf16(ptr + sizeof(simd16<T>) * 3);
+  }
+
+  is_utf8_really_inline uint64_t to_bitmask() const {
+    uint64_t r0 = uint32_t(this->chunks[0].to_bitmask());
+    uint64_t r1 = this->chunks[1].to_bitmask();
+    uint64_t r2 = this->chunks[2].to_bitmask();
+    uint64_t r3 = this->chunks[3].to_bitmask();
+    return r0 | (r1 << 16) | (r2 << 32) | (r3 << 48);
+  }
+
+  is_utf8_really_inline void swap_bytes() {
+    this->chunks[0] = this->chunks[0].swap_bytes();
+    this->chunks[1] = this->chunks[1].swap_bytes();
+    this->chunks[2] = this->chunks[2].swap_bytes();
+    this->chunks[3] = this->chunks[3].swap_bytes();
+  }
+
+  is_utf8_really_inline uint64_t eq(const T m) const {
+    const simd16<T> mask = simd16<T>::splat(m);
+    return simd16x32<bool>(this->chunks[0] == mask, this->chunks[1] == mask,
+                           this->chunks[2] == mask, this->chunks[3] == mask)
+        .to_bitmask();
+  }
+
+  is_utf8_really_inline uint64_t eq(const simd16x32<uint16_t> &other) const {
+    return simd16x32<bool>(this->chunks[0] == other.chunks[0],
+                           this->chunks[1] == other.chunks[1],
+                           this->chunks[2] == other.chunks[2],
+                           this->chunks[3] == other.chunks[3])
+        .to_bitmask();
+  }
+
+  is_utf8_really_inline uint64_t lteq(const T m) const {
+    const simd16<T> mask = simd16<T>::splat(m);
+    return simd16x32<bool>(this->chunks[0] <= mask, this->chunks[1] <= mask,
+                           this->chunks[2] <= mask, this->chunks[3] <= mask)
+        .to_bitmask();
+  }
+
+  is_utf8_really_inline uint64_t in_range(const T low, const T high) const {
+    const simd16<T> mask_low = simd16<T>::splat(low);
+    const simd16<T> mask_high = simd16<T>::splat(high);
+
+    return simd16x32<bool>(
+               (this->chunks[0] <= mask_high) & (this->chunks[0] >= mask_low),
+               (this->chunks[1] <= mask_high) & (this->chunks[1] >= mask_low),
+               (this->chunks[2] <= mask_high) & (this->chunks[2] >= mask_low),
+               (this->chunks[3] <= mask_high) & (this->chunks[3] >= mask_low))
+        .to_bitmask();
+  }
+  is_utf8_really_inline uint64_t not_in_range(const T low, const T high) const {
+    const simd16<T> mask_low = simd16<T>::splat(static_cast<T>(low - 1));
+    const simd16<T> mask_high = simd16<T>::splat(static_cast<T>(high + 1));
+    return simd16x32<bool>(
+               (this->chunks[0] >= mask_high) | (this->chunks[0] <= mask_low),
+               (this->chunks[1] >= mask_high) | (this->chunks[1] <= mask_low),
+               (this->chunks[2] >= mask_high) | (this->chunks[2] <= mask_low),
+               (this->chunks[3] >= mask_high) | (this->chunks[3] <= mask_low))
+        .to_bitmask();
+  }
+  is_utf8_really_inline uint64_t lt(const T m) const {
+    const simd16<T> mask = simd16<T>::splat(m);
+    return simd16x32<bool>(this->chunks[0] < mask, this->chunks[1] < mask,
+                           this->chunks[2] < mask, this->chunks[3] < mask)
+        .to_bitmask();
+  }
+}; // struct simd16x32<T>
+
+} // namespace simd
+} // unnamed namespace
+} // namespace westmere
+} // namespace is_utf8_internals
+
+#endif // IS_UTF8_WESTMERE_SIMD_INPUT_H
+
+IS_UTF8_UNTARGET_REGION
+
+#endif // IS_UTF8_IMPLEMENTATION_WESTMERE
+#endif // IS_UTF8_WESTMERE_COMMON_H
+
+#ifndef IS_UTF8_FALLBACK_H
+#define IS_UTF8_FALLBACK_H
+
+// Note that fallback.h is always imported last.
+
+// Default Fallback to on unless a builtin implementation has already been
+// selected.
+#ifndef IS_UTF8_IMPLEMENTATION_FALLBACK
+#if IS_UTF8_CAN_ALWAYS_RUN_ARM64 || IS_UTF8_CAN_ALWAYS_RUN_ICELAKE ||          \
+    IS_UTF8_CAN_ALWAYS_RUN_HASWELL || IS_UTF8_CAN_ALWAYS_RUN_WESTMERE ||       \
+    IS_UTF8_CAN_ALWAYS_RUN_PPC64
+#define IS_UTF8_IMPLEMENTATION_FALLBACK 0
+#else
+#define IS_UTF8_IMPLEMENTATION_FALLBACK 1
+#endif
+#endif
+
+#define IS_UTF8_CAN_ALWAYS_RUN_FALLBACK (IS_UTF8_IMPLEMENTATION_FALLBACK)
+
+#if IS_UTF8_IMPLEMENTATION_FALLBACK
+
+namespace is_utf8_internals {
+/**
+ * Fallback implementation (runs on any machine).
+ */
+namespace fallback {} // namespace fallback
+} // namespace is_utf8_internals
+
+#ifndef IS_UTF8_FALLBACK_IMPLEMENTATION_H
+#define IS_UTF8_FALLBACK_IMPLEMENTATION_H
+
+namespace is_utf8_internals {
+namespace fallback {
+
+class implementation final : public is_utf8_internals::implementation {
+public:
+  is_utf8_really_inline implementation()
+      : is_utf8_internals::implementation(
+            "fallback", "Generic fallback implementation", 0) {}
+  is_utf8_warn_unused bool validate_utf8(const char *buf,
+                                         size_t len) const noexcept final;
+};
+
+} // namespace fallback
+} // namespace is_utf8_internals
+
+#endif // IS_UTF8_FALLBACK_IMPLEMENTATION_H
+
+// redefining IS_UTF8_IMPLEMENTATION to "fallback"
+// #define IS_UTF8_IMPLEMENTATION fallback
+
+// Declarations
+
+#ifndef IS_UTF8_FALLBACK_BITMANIPULATION_H
+#define IS_UTF8_FALLBACK_BITMANIPULATION_H
+
+#include <limits>
+
+namespace is_utf8_internals {
+namespace fallback {
+namespace {
+
+#if defined(_MSC_VER) && !defined(_M_ARM64) && !defined(_M_X64)
+static inline unsigned char _BitScanForward64(unsigned long *ret, uint64_t x) {
+  unsigned long x0 = (unsigned long)x, top, bottom;
+  _BitScanForward(&top, (unsigned long)(x >> 32));
+  _BitScanForward(&bottom, x0);
+  *ret = x0 ? bottom : 32 + top;
+  return x != 0;
+}
+static unsigned char _BitScanReverse64(unsigned long *ret, uint64_t x) {
+  unsigned long x1 = (unsigned long)(x >> 32), top, bottom;
+  _BitScanReverse(&top, x1);
+  _BitScanReverse(&bottom, (unsigned long)x);
+  *ret = x1 ? top + 32 : bottom;
+  return x != 0;
+}
+#endif
+
+} // unnamed namespace
+} // namespace fallback
+} // namespace is_utf8_internals
+
+#endif // IS_UTF8_FALLBACK_BITMANIPULATION_H
+
+#endif // IS_UTF8_IMPLEMENTATION_FALLBACK
+#endif // IS_UTF8_FALLBACK_H
+
+namespace is_utf8_internals {
+bool implementation::supported_by_runtime_system() const {
+  uint32_t required_instruction_sets = this->required_instruction_sets();
+  uint32_t supported_instruction_sets =
+      internal::detect_supported_architectures();
+  return ((supported_instruction_sets & required_instruction_sets) ==
+          required_instruction_sets);
+}
+
+namespace internal {
+
+// Static array of known implementations. We're hoping these get baked into the
+// executable without requiring a static initializer.
+
+#if IS_UTF8_IMPLEMENTATION_ICELAKE
+const icelake::implementation icelake_singleton{};
+#endif
+#if IS_UTF8_IMPLEMENTATION_HASWELL
+const haswell::implementation haswell_singleton{};
+#endif
+#if IS_UTF8_IMPLEMENTATION_WESTMERE
+const westmere::implementation westmere_singleton{};
+#endif
+#if IS_UTF8_IMPLEMENTATION_ARM64
+const arm64::implementation arm64_singleton{};
+#endif
+#if IS_UTF8_IMPLEMENTATION_PPC64
+const ppc64::implementation ppc64_singleton{};
+#endif
+#if IS_UTF8_IMPLEMENTATION_FALLBACK
+const fallback::implementation fallback_singleton{};
+#endif
+
+/**
+ * @private Detects best supported implementation on first use, and sets it
+ */
+class detect_best_supported_implementation_on_first_use final
+    : public implementation {
+public:
+  const std::string &name() const noexcept final { return set_best()->name(); }
+  const std::string &description() const noexcept final {
+    return set_best()->description();
+  }
+  uint32_t required_instruction_sets() const noexcept final {
+    return set_best()->required_instruction_sets();
+  }
+
+  is_utf8_warn_unused bool
+  validate_utf8(const char *buf, size_t len) const noexcept final override {
+    return set_best()->validate_utf8(buf, len);
+  }
+
+  is_utf8_really_inline
+  detect_best_supported_implementation_on_first_use() noexcept
+      : implementation("best_supported_detector",
+                       "Detects the best supported implementation and sets it",
+                       0) {}
+
+private:
+  const implementation *set_best() const noexcept;
+};
+
+const detect_best_supported_implementation_on_first_use
+    detect_best_supported_implementation_on_first_use_singleton;
+
+const std::initializer_list<const implementation *>
+    available_implementation_pointers {
+#if IS_UTF8_IMPLEMENTATION_ICELAKE
+  &icelake_singleton,
+#endif
+#if IS_UTF8_IMPLEMENTATION_HASWELL
+      &haswell_singleton,
+#endif
+#if IS_UTF8_IMPLEMENTATION_WESTMERE
+      &westmere_singleton,
+#endif
+#if IS_UTF8_IMPLEMENTATION_ARM64
+      &arm64_singleton,
+#endif
+#if IS_UTF8_IMPLEMENTATION_PPC64
+      &ppc64_singleton,
+#endif
+#if IS_UTF8_IMPLEMENTATION_FALLBACK
+      &fallback_singleton,
+#endif
+}; // available_implementation_pointers
+
+// So we can return UNSUPPORTED_ARCHITECTURE from the parser when there is no
+// support
+class unsupported_implementation final : public implementation {
+public:
+  is_utf8_warn_unused bool validate_utf8(const char *,
+                                         size_t) const noexcept final override {
+    return false; // Just refuse to validate. Given that we have a fallback
+                  // implementation
+    // it seems unlikely that unsupported_implementation will ever be used. If
+    // it is used, then it will flag all strings as invalid. The alternative is
+    // to return an error_code from which the user has to figure out whether the
+    // string is valid UTF-8... which seems like a lot of work just to handle
+    // the very unlikely case that we have an unsupported implementation. And,
+    // when it does happen (that we have an unsupported implementation), what
+    // are the chances that the programmer has a fallback? Given that *we*
+    // provide the fallback, it implies that the programmer would need a
+    // fallback for our fallback.
+  }
+
+  unsupported_implementation()
+      : implementation("unsupported",
+                       "Unsupported CPU (no detected SIMD instructions)", 0) {}
+};
+
+const unsupported_implementation unsupported_singleton{};
+
+size_t available_implementation_list::size() const noexcept {
+  return internal::available_implementation_pointers.size();
+}
+const implementation *const *
+available_implementation_list::begin() const noexcept {
+  return internal::available_implementation_pointers.begin();
+}
+const implementation *const *
+available_implementation_list::end() const noexcept {
+  return internal::available_implementation_pointers.end();
+}
+const implementation *
+available_implementation_list::detect_best_supported() const noexcept {
+  // They are prelisted in priority order, so we just go down the list
+  uint32_t supported_instruction_sets =
+      internal::detect_supported_architectures();
+  for (const implementation *impl :
+       internal::available_implementation_pointers) {
+    uint32_t required_instruction_sets = impl->required_instruction_sets();
+    if ((supported_instruction_sets & required_instruction_sets) ==
+        required_instruction_sets) {
+      return impl;
+    }
+  }
+  return &unsupported_singleton; // this should never happen?
+}
+
+const implementation *
+detect_best_supported_implementation_on_first_use::set_best() const noexcept {
+  IS_UTF8_PUSH_DISABLE_WARNINGS
+  IS_UTF8_DISABLE_DEPRECATED_WARNING // Disable CRT_SECURE warning on MSVC:
+                                     // manually verified this is safe
+      char *force_implementation_name = getenv("IS_UTF8_FORCE_IMPLEMENTATION");
+  IS_UTF8_POP_DISABLE_WARNINGS
+
+  if (force_implementation_name) {
+    auto force_implementation =
+        available_implementations[force_implementation_name];
+    if (force_implementation) {
+      return active_implementation = force_implementation;
+    } else {
+      // Note: abort() and stderr usage within the library is forbidden.
+      return active_implementation = &unsupported_singleton;
+    }
+  }
+  return active_implementation =
+             available_implementations.detect_best_supported();
+}
+
+} // namespace internal
+
+IS_UTF8_DLLIMPORTEXPORT const internal::available_implementation_list
+    available_implementations{};
+IS_UTF8_DLLIMPORTEXPORT internal::atomic_ptr<const implementation>
+    active_implementation{
+        &internal::detect_best_supported_implementation_on_first_use_singleton};
+
+is_utf8_warn_unused bool validate_utf8(const char *buf, size_t len) noexcept {
+  return active_implementation->validate_utf8(buf, len);
+}
+
+const implementation *builtin_implementation() {
+  static const implementation *builtin_impl =
+      available_implementations[IS_UTF8_STRINGIFY(
+          IS_UTF8_BUILTIN_IMPLEMENTATION)];
+  return builtin_impl;
+}
+
+} // namespace is_utf8_internals
+
+// The scalar routines should be included once.
+
+#ifndef IS_UTF8_UTF8_H
+#define IS_UTF8_UTF8_H
+
+namespace is_utf8_internals {
+namespace scalar {
+namespace {
+namespace utf8 {
+#if IS_UTF8_IS_ARM64
+// not needed
+#else
+// credit: based on code from Google Fuchsia (Apache Licensed)
+inline is_utf8_warn_unused bool validate(const char *buf, size_t len) noexcept {
+  const uint8_t *data = reinterpret_cast<const uint8_t *>(buf);
+  uint64_t pos = 0;
+  uint32_t code_point = 0;
+  while (pos < len) {
+    // check of the next 8 bytes are ascii.
+    uint64_t next_pos = pos + 16;
+    if (next_pos <=
+        len) { // if it is safe to read 8 more bytes, check that they are ascii
+      uint64_t v1;
+      std::memcpy(&v1, data + pos, sizeof(uint64_t));
+      uint64_t v2;
+      std::memcpy(&v2, data + pos + sizeof(uint64_t), sizeof(uint64_t));
+      uint64_t v{v1 | v2};
+      if ((v & 0x8080808080808080) == 0) {
+        pos = next_pos;
+        continue;
+      }
+    }
+    unsigned char byte = data[pos];
+
+    while (byte < 0b10000000) {
+      if (++pos == len) {
+        return true;
+      }
+      byte = data[pos];
+    }
+
+    if ((byte & 0b11100000) == 0b11000000) {
+      next_pos = pos + 2;
+      if (next_pos > len) {
+        return false;
+      }
+      if ((data[pos + 1] & 0b11000000) != 0b10000000) {
+        return false;
+      }
+      // range check
+      code_point = (byte & 0b00011111) << 6 | (data[pos + 1] & 0b00111111);
+      if ((code_point < 0x80) || (0x7ff < code_point)) {
+        return false;
+      }
+    } else if ((byte & 0b11110000) == 0b11100000) {
+      next_pos = pos + 3;
+      if (next_pos > len) {
+        return false;
+      }
+      if ((data[pos + 1] & 0b11000000) != 0b10000000) {
+        return false;
+      }
+      if ((data[pos + 2] & 0b11000000) != 0b10000000) {
+        return false;
+      }
+      // range check
+      code_point = (byte & 0b00001111) << 12 |
+                   (data[pos + 1] & 0b00111111) << 6 |
+                   (data[pos + 2] & 0b00111111);
+      if ((code_point < 0x800) || (0xffff < code_point) ||
+          (0xd7ff < code_point && code_point < 0xe000)) {
+        return false;
+      }
+    } else if ((byte & 0b11111000) == 0b11110000) { // 0b11110000
+      next_pos = pos + 4;
+      if (next_pos > len) {
+        return false;
+      }
+      if ((data[pos + 1] & 0b11000000) != 0b10000000) {
+        return false;
+      }
+      if ((data[pos + 2] & 0b11000000) != 0b10000000) {
+        return false;
+      }
+      if ((data[pos + 3] & 0b11000000) != 0b10000000) {
+        return false;
+      }
+      // range check
+      code_point =
+          (byte & 0b00000111) << 18 | (data[pos + 1] & 0b00111111) << 12 |
+          (data[pos + 2] & 0b00111111) << 6 | (data[pos + 3] & 0b00111111);
+      if (code_point <= 0xffff || 0x10ffff < code_point) {
+        return false;
+      }
+    } else {
+      // we may have a continuation
+      return false;
+    }
+    pos = next_pos;
+  }
+  return true;
+}
+#endif
+} // namespace utf8
+} // unnamed namespace
+} // namespace scalar
+} // namespace is_utf8_internals
+
+#endif
+
+IS_UTF8_PUSH_DISABLE_WARNINGS
+IS_UTF8_DISABLE_UNDESIRED_WARNINGS
+
+#if IS_UTF8_IMPLEMENTATION_ARM64
+
+// redefining IS_UTF8_IMPLEMENTATION to "arm64"
+// #define IS_UTF8_IMPLEMENTATION arm64
+
+namespace is_utf8_internals {
+namespace arm64 {
+namespace {
+#ifndef IS_UTF8_ARM64_H
+#error "arm64.h must be included"
+#endif
+using namespace simd;
+
+is_utf8_really_inline bool is_ascii(const simd8x64<uint8_t> &input) {
+  simd8<uint8_t> bits = input.reduce_or();
+  return bits.max_val() < 0b10000000u;
+}
+
+is_utf8_unused is_utf8_really_inline simd8<bool>
+must_be_continuation(const simd8<uint8_t> prev1, const simd8<uint8_t> prev2,
+                     const simd8<uint8_t> prev3) {
+  simd8<bool> is_second_byte = prev1 >= uint8_t(0b11000000u);
+  simd8<bool> is_third_byte = prev2 >= uint8_t(0b11100000u);
+  simd8<bool> is_fourth_byte = prev3 >= uint8_t(0b11110000u);
+  // Use ^ instead of | for is_*_byte, because ^ is commutative, and the caller
+  // is using ^ as well. This will work fine because we only have to report
+  // errors for cases with 0-1 lead bytes. Multiple lead bytes implies 2
+  // overlapping multibyte characters, and if that happens, there is guaranteed
+  // to be at least *one* lead byte that is part of only 1 other multibyte
+  // character. The error will be detected there.
+  return is_second_byte ^ is_third_byte ^ is_fourth_byte;
+}
+
+is_utf8_really_inline simd8<bool>
+must_be_2_3_continuation(const simd8<uint8_t> prev2,
+                         const simd8<uint8_t> prev3) {
+  simd8<bool> is_third_byte = prev2 >= uint8_t(0b11100000u);
+  simd8<bool> is_fourth_byte = prev3 >= uint8_t(0b11110000u);
+  return is_third_byte ^ is_fourth_byte;
+}
+
+} // unnamed namespace
+} // namespace arm64
+} // namespace is_utf8_internals
+
+namespace is_utf8_internals {
+namespace arm64 {
+namespace {
+
+// Walks through a buffer in block-sized increments, loading the last part with
+// spaces
+template <size_t STEP_SIZE> struct buf_block_reader {
+public:
+  is_utf8_really_inline buf_block_reader(const uint8_t *_buf, size_t _len);
+  is_utf8_really_inline size_t block_index();
+  is_utf8_really_inline bool has_full_block() const;
+  is_utf8_really_inline const uint8_t *full_block() const;
+  /**
+   * Get the last block, padded with spaces.
+   *
+   * There will always be a last block, with at least 1 byte, unless len == 0
+   * (in which case this function fills the buffer with spaces and returns 0. In
+   * particular, if len == STEP_SIZE there will be 0 full_blocks and 1 remainder
+   * block with STEP_SIZE bytes and no spaces for padding.
+   *
+   * @return the number of effective characters in the last block.
+   */
+  is_utf8_really_inline size_t get_remainder(uint8_t *dst) const;
+  is_utf8_really_inline void advance();
+
+private:
+  const uint8_t *buf;
+  const size_t len;
+  const size_t lenminusstep;
+  size_t idx;
+};
+
+// Routines to print masks and text for debugging bitmask operations
+is_utf8_unused static char *format_input_text_64(const uint8_t *text) {
+  static char *buf =
+      reinterpret_cast<char *>(malloc(sizeof(simd8x64<uint8_t>) + 1));
+  for (size_t i = 0; i < sizeof(simd8x64<uint8_t>); i++) {
+    buf[i] = int8_t(text[i]) < ' ' ? '_' : int8_t(text[i]);
+  }
+  buf[sizeof(simd8x64<uint8_t>)] = '\0';
+  return buf;
+}
+
+// Routines to print masks and text for debugging bitmask operations
+is_utf8_unused static char *format_input_text(const simd8x64<uint8_t> &in) {
+  static char *buf =
+      reinterpret_cast<char *>(malloc(sizeof(simd8x64<uint8_t>) + 1));
+  in.store(reinterpret_cast<uint8_t *>(buf));
+  for (size_t i = 0; i < sizeof(simd8x64<uint8_t>); i++) {
+    if (buf[i] < ' ') {
+      buf[i] = '_';
+    }
+  }
+  buf[sizeof(simd8x64<uint8_t>)] = '\0';
+  return buf;
+}
+
+is_utf8_unused static char *format_mask(uint64_t mask) {
+  static char *buf = reinterpret_cast<char *>(malloc(64 + 1));
+  for (size_t i = 0; i < 64; i++) {
+    buf[i] = (mask & (size_t(1) << i)) ? 'X' : ' ';
+  }
+  buf[64] = '\0';
+  return buf;
+}
+
+template <size_t STEP_SIZE>
+is_utf8_really_inline
+buf_block_reader<STEP_SIZE>::buf_block_reader(const uint8_t *_buf, size_t _len)
+    : buf{_buf}, len{_len},
+      lenminusstep{len < STEP_SIZE ? 0 : len - STEP_SIZE}, idx{0} {}
+
+template <size_t STEP_SIZE>
+is_utf8_really_inline size_t buf_block_reader<STEP_SIZE>::block_index() {
+  return idx;
+}
+
+template <size_t STEP_SIZE>
+is_utf8_really_inline bool buf_block_reader<STEP_SIZE>::has_full_block() const {
+  return idx < lenminusstep;
+}
+
+template <size_t STEP_SIZE>
+is_utf8_really_inline const uint8_t *
+buf_block_reader<STEP_SIZE>::full_block() const {
+  return &buf[idx];
+}
+
+template <size_t STEP_SIZE>
+is_utf8_really_inline size_t
+buf_block_reader<STEP_SIZE>::get_remainder(uint8_t *dst) const {
+  if (len == idx) {
+    return 0;
+  } // memcpy(dst, null, 0) will trigger an error with some sanitizers
+  std::memset(dst, 0x20,
+              STEP_SIZE); // std::memset STEP_SIZE because it's more efficient
+                          // to write out 8 or 16 bytes at once.
+  std::memcpy(dst, buf + idx, len - idx);
+  return len - idx;
+}
+
+template <size_t STEP_SIZE>
+is_utf8_really_inline void buf_block_reader<STEP_SIZE>::advance() {
+  idx += STEP_SIZE;
+}
+
+} // unnamed namespace
+} // namespace arm64
+} // namespace is_utf8_internals
+
+namespace is_utf8_internals {
+namespace arm64 {
+namespace {
+namespace utf8_validation {
+
+using namespace simd;
+
+is_utf8_really_inline simd8<uint8_t>
+check_special_cases(const simd8<uint8_t> input, const simd8<uint8_t> prev1) {
+  // Bit 0 = Too Short (lead byte/ASCII followed by lead byte/ASCII)
+  // Bit 1 = Too Long (ASCII followed by continuation)
+  // Bit 2 = Overlong 3-byte
+  // Bit 4 = Surrogate
+  // Bit 5 = Overlong 2-byte
+  // Bit 7 = Two Continuations
+  constexpr const uint8_t TOO_SHORT = 1 << 0;  // 11______ 0_______
+                                               // 11______ 11______
+  constexpr const uint8_t TOO_LONG = 1 << 1;   // 0_______ 10______
+  constexpr const uint8_t OVERLONG_3 = 1 << 2; // 11100000 100_____
+  constexpr const uint8_t SURROGATE = 1 << 4;  // 11101101 101_____
+  constexpr const uint8_t OVERLONG_2 = 1 << 5; // 1100000_ 10______
+  constexpr const uint8_t TWO_CONTS = 1 << 7;  // 10______ 10______
+  constexpr const uint8_t TOO_LARGE = 1 << 3;  // 11110100 1001____
+                                               // 11110100 101_____
+                                               // 11110101 1001____
+                                               // 11110101 101_____
+                                               // 1111011_ 1001____
+                                               // 1111011_ 101_____
+                                               // 11111___ 1001____
+                                               // 11111___ 101_____
+  constexpr const uint8_t TOO_LARGE_1000 = 1 << 6;
+  // 11110101 1000____
+  // 1111011_ 1000____
+  // 11111___ 1000____
+  constexpr const uint8_t OVERLONG_4 = 1 << 6; // 11110000 1000____
+
+  const simd8<uint8_t> byte_1_high = prev1.shr<4>().lookup_16<uint8_t>(
+      // 0_______ ________ <ASCII in byte 1>
+      TOO_LONG, TOO_LONG, TOO_LONG, TOO_LONG, TOO_LONG, TOO_LONG, TOO_LONG,
+      TOO_LONG,
+      // 10______ ________ <continuation in byte 1>
+      TWO_CONTS, TWO_CONTS, TWO_CONTS, TWO_CONTS,
+      // 1100____ ________ <two byte lead in byte 1>
+      TOO_SHORT | OVERLONG_2,
+      // 1101____ ________ <two byte lead in byte 1>
+      TOO_SHORT,
+      // 1110____ ________ <three byte lead in byte 1>
+      TOO_SHORT | OVERLONG_3 | SURROGATE,
+      // 1111____ ________ <four+ byte lead in byte 1>
+      TOO_SHORT | TOO_LARGE | TOO_LARGE_1000 | OVERLONG_4);
+  constexpr const uint8_t CARRY =
+      TOO_SHORT | TOO_LONG | TWO_CONTS; // These all have ____ in byte 1 .
+  const simd8<uint8_t> byte_1_low =
+      (prev1 & 0x0F)
+          .lookup_16<uint8_t>(
+              // ____0000 ________
+              CARRY | OVERLONG_3 | OVERLONG_2 | OVERLONG_4,
+              // ____0001 ________
+              CARRY | OVERLONG_2,
+              // ____001_ ________
+              CARRY, CARRY,
+
+              // ____0100 ________
+              CARRY | TOO_LARGE,
+              // ____0101 ________
+              CARRY | TOO_LARGE | TOO_LARGE_1000,
+              // ____011_ ________
+              CARRY | TOO_LARGE | TOO_LARGE_1000,
+              CARRY | TOO_LARGE | TOO_LARGE_1000,
+
+              // ____1___ ________
+              CARRY | TOO_LARGE | TOO_LARGE_1000,
+              CARRY | TOO_LARGE | TOO_LARGE_1000,
+              CARRY | TOO_LARGE | TOO_LARGE_1000,
+              CARRY | TOO_LARGE | TOO_LARGE_1000,
+              CARRY | TOO_LARGE | TOO_LARGE_1000,
+              // ____1101 ________
+              CARRY | TOO_LARGE | TOO_LARGE_1000 | SURROGATE,
+              CARRY | TOO_LARGE | TOO_LARGE_1000,
+              CARRY | TOO_LARGE | TOO_LARGE_1000);
+  const simd8<uint8_t> byte_2_high = input.shr<4>().lookup_16<uint8_t>(
+      // ________ 0_______ <ASCII in byte 2>
+      TOO_SHORT, TOO_SHORT, TOO_SHORT, TOO_SHORT, TOO_SHORT, TOO_SHORT,
+      TOO_SHORT, TOO_SHORT,
+
+      // ________ 1000____
+      TOO_LONG | OVERLONG_2 | TWO_CONTS | OVERLONG_3 | TOO_LARGE_1000 |
+          OVERLONG_4,
+      // ________ 1001____
+      TOO_LONG | OVERLONG_2 | TWO_CONTS | OVERLONG_3 | TOO_LARGE,
+      // ________ 101_____
+      TOO_LONG | OVERLONG_2 | TWO_CONTS | SURROGATE | TOO_LARGE,
+      TOO_LONG | OVERLONG_2 | TWO_CONTS | SURROGATE | TOO_LARGE,
+
+      // ________ 11______
+      TOO_SHORT, TOO_SHORT, TOO_SHORT, TOO_SHORT);
+  return (byte_1_high & byte_1_low & byte_2_high);
+}
+is_utf8_really_inline simd8<uint8_t>
+check_multibyte_lengths(const simd8<uint8_t> input,
+                        const simd8<uint8_t> prev_input,
+                        const simd8<uint8_t> sc) {
+  simd8<uint8_t> prev2 = input.prev<2>(prev_input);
+  simd8<uint8_t> prev3 = input.prev<3>(prev_input);
+  simd8<uint8_t> must23 =
+      simd8<uint8_t>(must_be_2_3_continuation(prev2, prev3));
+  simd8<uint8_t> must23_80 = must23 & uint8_t(0x80);
+  return must23_80 ^ sc;
+}
+
+//
+// Return nonzero if there are incomplete multibyte characters at the end of the
+// block: e.g. if there is a 4-byte character, but it's 3 bytes from the end.
+//
+is_utf8_really_inline simd8<uint8_t> is_incomplete(const simd8<uint8_t> input) {
+  // If the previous input's last 3 bytes match this, they're too short (they
+  // ended at EOF):
+  // ... 1111____ 111_____ 11______
+  static const uint8_t max_array[32] = {255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        0b11110000u - 1,
+                                        0b11100000u - 1,
+                                        0b11000000u - 1};
+  const simd8<uint8_t> max_value(
+      &max_array[sizeof(max_array) - sizeof(simd8<uint8_t>)]);
+  return input.gt_bits(max_value);
+}
+
+struct utf8_checker {
+  // If this is nonzero, there has been a UTF-8 error.
+  simd8<uint8_t> error;
+  // The last input we received
+  simd8<uint8_t> prev_input_block;
+  // Whether the last input we received was incomplete (used for ASCII fast
+  // path)
+  simd8<uint8_t> prev_incomplete;
+
+  //
+  // Check whether the current bytes are valid UTF-8.
+  //
+  is_utf8_really_inline void check_utf8_bytes(const simd8<uint8_t> input,
+                                              const simd8<uint8_t> prev_input) {
+    // Flip prev1...prev3 so we can easily determine if they are 2+, 3+ or 4+
+    // lead bytes (2, 3, 4-byte leads become large positive numbers instead of
+    // small negative numbers)
+    simd8<uint8_t> prev1 = input.prev<1>(prev_input);
+    simd8<uint8_t> sc = check_special_cases(input, prev1);
+    this->error |= check_multibyte_lengths(input, prev_input, sc);
+  }
+
+  // The only problem that can happen at EOF is that a multibyte character is
+  // too short or a byte value too large in the last bytes: check_special_cases
+  // only checks for bytes too large in the first of two bytes.
+  is_utf8_really_inline void check_eof() {
+    // If the previous block had incomplete UTF-8 characters at the end, an
+    // ASCII block can't possibly finish them.
+    this->error |= this->prev_incomplete;
+  }
+
+  is_utf8_really_inline void check_next_input(const simd8x64<uint8_t> &input) {
+    if (is_utf8_likely(is_ascii(input))) {
+      this->error |= this->prev_incomplete;
+    } else {
+      // you might think that a for-loop would work, but under Visual Studio, it
+      // is not good enough.
+      static_assert((simd8x64<uint8_t>::NUM_CHUNKS == 2) ||
+                        (simd8x64<uint8_t>::NUM_CHUNKS == 4),
+                    "We support either two or four chunks per 64-byte block.");
+      if (simd8x64<uint8_t>::NUM_CHUNKS == 2) {
+        this->check_utf8_bytes(input.chunks[0], this->prev_input_block);
+        this->check_utf8_bytes(input.chunks[1], input.chunks[0]);
+      } else if (simd8x64<uint8_t>::NUM_CHUNKS == 4) {
+        this->check_utf8_bytes(input.chunks[0], this->prev_input_block);
+        this->check_utf8_bytes(input.chunks[1], input.chunks[0]);
+        this->check_utf8_bytes(input.chunks[2], input.chunks[1]);
+        this->check_utf8_bytes(input.chunks[3], input.chunks[2]);
+      }
+      this->prev_incomplete =
+          is_incomplete(input.chunks[simd8x64<uint8_t>::NUM_CHUNKS - 1]);
+      this->prev_input_block = input.chunks[simd8x64<uint8_t>::NUM_CHUNKS - 1];
+    }
+  }
+
+  // do not forget to call check_eof!
+  is_utf8_really_inline bool errors() const {
+    return this->error.any_bits_set_anywhere();
+  }
+
+}; // struct utf8_checker
+} // namespace utf8_validation
+
+using utf8_validation::utf8_checker;
+
+} // unnamed namespace
+} // namespace arm64
+} // namespace is_utf8_internals
+
+namespace is_utf8_internals {
+namespace arm64 {
+namespace {
+namespace utf8_validation {
+
+/**
+ * Validates that the string is actual UTF-8.
+ */
+template <class checker>
+bool generic_validate_utf8(const uint8_t *input, size_t length) {
+  checker c{};
+  buf_block_reader<64> reader(input, length);
+  while (reader.has_full_block()) {
+    simd::simd8x64<uint8_t> in(reader.full_block());
+    c.check_next_input(in);
+    reader.advance();
+  }
+  uint8_t block[64]{};
+  reader.get_remainder(block);
+  simd::simd8x64<uint8_t> in(block);
+  c.check_next_input(in);
+  reader.advance();
+  c.check_eof();
+  return !c.errors();
+}
+
+bool generic_validate_utf8(const char *input, size_t length) {
+  return generic_validate_utf8<utf8_checker>(
+      reinterpret_cast<const uint8_t *>(input), length);
+}
+
+} // namespace utf8_validation
+} // unnamed namespace
+} // namespace arm64
+} // namespace is_utf8_internals
+
+//
+// Implementation-specific overrides
+//
+namespace is_utf8_internals {
+namespace arm64 {
+
+is_utf8_warn_unused bool
+implementation::validate_utf8(const char *buf, size_t len) const noexcept {
+  return arm64::utf8_validation::generic_validate_utf8(buf, len);
+}
+
+} // namespace arm64
+} // namespace is_utf8_internals
+
+#endif
+#if IS_UTF8_IMPLEMENTATION_FALLBACK
+
+// redefining IS_UTF8_IMPLEMENTATION to "fallback"
+// #define IS_UTF8_IMPLEMENTATION fallback
+
+namespace is_utf8_internals {
+namespace fallback {
+
+is_utf8_warn_unused bool
+implementation::validate_utf8(const char *buf, size_t len) const noexcept {
+  return scalar::utf8::validate(buf, len);
+}
+
+} // namespace fallback
+} // namespace is_utf8_internals
+
+#endif
+#if IS_UTF8_IMPLEMENTATION_ICELAKE
+
+// redefining IS_UTF8_IMPLEMENTATION to "icelake"
+// #define IS_UTF8_IMPLEMENTATION icelake
+IS_UTF8_TARGET_ICELAKE
+
+#if IS_UTF8_GCC11ORMORE // workaround for
+                        // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=105593
+IS_UTF8_DISABLE_GCC_WARNING(-Wmaybe-uninitialized)
+#endif // end of workaround
+
+namespace is_utf8_internals {
+namespace icelake {
+namespace {
+#ifndef IS_UTF8_ICELAKE_H
+#error "icelake.h must be included"
+#endif
+
+/**
+ * Store the last N bytes of previous followed by 512-N bytes from input.
+ */
+template <int N> __m512i prev(__m512i input, __m512i previous) {
+  static_assert(N <= 32, "N must be no larger than 32");
+  const __m512i movemask =
+      _mm512_setr_epi32(28, 29, 30, 31, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11);
+  const __m512i rotated = _mm512_permutex2var_epi32(input, movemask, previous);
+#if IS_UTF8_GCC8 || IS_UTF8_GCC9
+  constexpr int shift = 16 - N; // workaround for GCC8,9
+  return _mm512_alignr_epi8(input, rotated, shift);
+#else
+  return _mm512_alignr_epi8(input, rotated, 16 - N);
+#endif // IS_UTF8_GCC8 || IS_UTF8_GCC9
+}
+
+is_utf8_really_inline __m512i check_special_cases(__m512i input,
+                                                  const __m512i prev1) {
+  __m512i mask1 = _mm512_setr_epi64(0x0202020202020202, 0x4915012180808080,
+                                    0x0202020202020202, 0x4915012180808080,
+                                    0x0202020202020202, 0x4915012180808080,
+                                    0x0202020202020202, 0x4915012180808080);
+  const __m512i v_0f = _mm512_set1_epi8(0x0f);
+  __m512i index1 = _mm512_and_si512(_mm512_srli_epi16(prev1, 4), v_0f);
+
+  __m512i byte_1_high = _mm512_shuffle_epi8(mask1, index1);
+  __m512i mask2 = _mm512_setr_epi64(0xcbcbcb8b8383a3e7, 0xcbcbdbcbcbcbcbcb,
+                                    0xcbcbcb8b8383a3e7, 0xcbcbdbcbcbcbcbcb,
+                                    0xcbcbcb8b8383a3e7, 0xcbcbdbcbcbcbcbcb,
+                                    0xcbcbcb8b8383a3e7, 0xcbcbdbcbcbcbcbcb);
+  __m512i index2 = _mm512_and_si512(prev1, v_0f);
+
+  __m512i byte_1_low = _mm512_shuffle_epi8(mask2, index2);
+  __m512i mask3 =
+      _mm512_setr_epi64(0x101010101010101, 0x1010101babaaee6, 0x101010101010101,
+                        0x1010101babaaee6, 0x101010101010101, 0x1010101babaaee6,
+                        0x101010101010101, 0x1010101babaaee6);
+  __m512i index3 = _mm512_and_si512(_mm512_srli_epi16(input, 4), v_0f);
+  __m512i byte_2_high = _mm512_shuffle_epi8(mask3, index3);
+  return _mm512_ternarylogic_epi64(byte_1_high, byte_1_low, byte_2_high, 128);
+}
+
+is_utf8_really_inline __m512i check_multibyte_lengths(const __m512i input,
+                                                      const __m512i prev_input,
+                                                      const __m512i sc) {
+  __m512i prev2 = prev<2>(input, prev_input);
+  __m512i prev3 = prev<3>(input, prev_input);
+  __m512i is_third_byte = _mm512_subs_epu8(
+      prev2, _mm512_set1_epi8(char(0b11011111))); // Only 111_____ will be > 0
+  __m512i is_fourth_byte = _mm512_subs_epu8(
+      prev3, _mm512_set1_epi8(char(0b11101111))); // Only 1111____ will be > 0
+  __m512i is_third_or_fourth_byte =
+      _mm512_or_si512(is_third_byte, is_fourth_byte);
+  const __m512i v_7f = _mm512_set1_epi8(char(0x7f));
+  is_third_or_fourth_byte = _mm512_adds_epu8(v_7f, is_third_or_fourth_byte);
+  // We want to compute (is_third_or_fourth_byte AND v80) XOR sc.
+  const __m512i v_80 = _mm512_set1_epi8(char(0x80));
+  return _mm512_ternarylogic_epi32(is_third_or_fourth_byte, v_80, sc,
+                                   0b1101010);
+  //__m512i is_third_or_fourth_byte_mask =
+  //_mm512_and_si512(is_third_or_fourth_byte, v_80); return
+  // _mm512_xor_si512(is_third_or_fourth_byte_mask, sc);
+}
+//
+// Return nonzero if there are incomplete multibyte characters at the end of the
+// block: e.g. if there is a 4-byte character, but it's 3 bytes from the end.
+//
+is_utf8_really_inline __m512i is_incomplete(const __m512i input) {
+  // If the previous input's last 3 bytes match this, they're too short (they
+  // ended at EOF):
+  // ... 1111____ 111_____ 11______
+  __m512i max_value = _mm512_setr_epi64(0xffffffffffffffff, 0xffffffffffffffff,
+                                        0xffffffffffffffff, 0xffffffffffffffff,
+                                        0xffffffffffffffff, 0xffffffffffffffff,
+                                        0xffffffffffffffff, 0xbfdfefffffffffff);
+  return _mm512_subs_epu8(input, max_value);
+}
+
+struct avx512_utf8_checker {
+  // If this is nonzero, there has been a UTF-8 error.
+  __m512i error{};
+
+  // The last input we received
+  __m512i prev_input_block{};
+  // Whether the last input we received was incomplete (used for ASCII fast
+  // path)
+  __m512i prev_incomplete{};
+
+  //
+  // Check whether the current bytes are valid UTF-8.
+  //
+  is_utf8_really_inline void check_utf8_bytes(const __m512i input,
+                                              const __m512i prev_input) {
+    // Flip prev1...prev3 so we can easily determine if they are 2+, 3+ or 4+
+    // lead bytes (2, 3, 4-byte leads become large positive numbers instead of
+    // small negative numbers)
+    __m512i prev1 = prev<1>(input, prev_input);
+    __m512i sc = check_special_cases(input, prev1);
+    this->error = _mm512_or_si512(
+        check_multibyte_lengths(input, prev_input, sc), this->error);
+  }
+
+  // The only problem that can happen at EOF is that a multibyte character is
+  // too short or a byte value too large in the last bytes: check_special_cases
+  // only checks for bytes too large in the first of two bytes.
+  is_utf8_really_inline void check_eof() {
+    // If the previous block had incomplete UTF-8 characters at the end, an
+    // ASCII block can't possibly finish them.
+    this->error = _mm512_or_si512(this->error, this->prev_incomplete);
+  }
+
+  // returns true if ASCII.
+  is_utf8_really_inline bool check_next_input(const __m512i input) {
+    const __m512i v_80 = _mm512_set1_epi8(char(0x80));
+    const __mmask64 ascii = _mm512_test_epi8_mask(input, v_80);
+    if (ascii == 0) {
+      this->error = _mm512_or_si512(this->error, this->prev_incomplete);
+      return true;
+    } else {
+      this->check_utf8_bytes(input, this->prev_input_block);
+      this->prev_incomplete = is_incomplete(input);
+      this->prev_input_block = input;
+      return false;
+    }
+  }
+  // do not forget to call check_eof!
+  is_utf8_really_inline bool errors() const {
+    return _mm512_test_epi8_mask(this->error, this->error) != 0;
+  }
+
+}; // struct avx512_utf8_checker
+
+} // namespace
+} // namespace icelake
+} // namespace is_utf8_internals
+
+namespace is_utf8_internals {
+namespace icelake {
+
+is_utf8_warn_unused bool
+implementation::validate_utf8(const char *buf, size_t len) const noexcept {
+  avx512_utf8_checker checker{};
+  const char *ptr = buf;
+  const char *end = ptr + len;
+  for (; ptr + 64 <= end; ptr += 64) {
+    const __m512i utf8 = _mm512_loadu_si512((const __m512i *)ptr);
+    checker.check_next_input(utf8);
+  }
+  {
+    const __m512i utf8 = _mm512_maskz_loadu_epi8((1ULL << (end - ptr)) - 1,
+                                                 (const __m512i *)ptr);
+    checker.check_next_input(utf8);
+  }
+  checker.check_eof();
+  return !checker.errors();
+}
+
+} // namespace icelake
+} // namespace is_utf8_internals
+
+IS_UTF8_UNTARGET_REGION
+
+#if IS_UTF8_GCC11ORMORE // workaround for
+                        // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=105593
+IS_UTF8_POP_DISABLE_WARNINGS
+#endif // end of workaround
+
+#endif
+#if IS_UTF8_IMPLEMENTATION_HASWELL
+
+// redefining IS_UTF8_IMPLEMENTATION to "haswell"
+// #define IS_UTF8_IMPLEMENTATION haswell
+IS_UTF8_TARGET_HASWELL
+
+#if IS_UTF8_GCC11ORMORE // workaround for
+                        // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=105593
+IS_UTF8_DISABLE_GCC_WARNING(-Wmaybe-uninitialized)
+#endif // end of workaround
+
+namespace is_utf8_internals {
+namespace haswell {
+namespace {
+#ifndef IS_UTF8_HASWELL_H
+#error "haswell.h must be included"
+#endif
+using namespace simd;
+
+is_utf8_really_inline bool is_ascii(const simd8x64<uint8_t> &input) {
+  return input.reduce_or().is_ascii();
+}
+
+is_utf8_unused is_utf8_really_inline simd8<bool>
+must_be_continuation(const simd8<uint8_t> prev1, const simd8<uint8_t> prev2,
+                     const simd8<uint8_t> prev3) {
+  simd8<uint8_t> is_second_byte =
+      prev1.saturating_sub(0b11000000u - 1); // Only 11______ will be > 0
+  simd8<uint8_t> is_third_byte =
+      prev2.saturating_sub(0b11100000u - 1); // Only 111_____ will be > 0
+  simd8<uint8_t> is_fourth_byte =
+      prev3.saturating_sub(0b11110000u - 1); // Only 1111____ will be > 0
+  // Caller requires a bool (all 1's). All values resulting from the subtraction
+  // will be <= 64, so signed comparison is fine.
+  return simd8<int8_t>(is_second_byte | is_third_byte | is_fourth_byte) >
+         int8_t(0);
+}
+
+is_utf8_really_inline simd8<bool>
+must_be_2_3_continuation(const simd8<uint8_t> prev2,
+                         const simd8<uint8_t> prev3) {
+  simd8<uint8_t> is_third_byte =
+      prev2.saturating_sub(0b11100000u - 1); // Only 111_____ will be > 0
+  simd8<uint8_t> is_fourth_byte =
+      prev3.saturating_sub(0b11110000u - 1); // Only 1111____ will be > 0
+  // Caller requires a bool (all 1's). All values resulting from the subtraction
+  // will be <= 64, so signed comparison is fine.
+  return simd8<int8_t>(is_third_byte | is_fourth_byte) > int8_t(0);
+}
+
+} // unnamed namespace
+} // namespace haswell
+} // namespace is_utf8_internals
+
+namespace is_utf8_internals {
+namespace haswell {
+namespace {
+
+// Walks through a buffer in block-sized increments, loading the last part with
+// spaces
+template <size_t STEP_SIZE> struct buf_block_reader {
+public:
+  is_utf8_really_inline buf_block_reader(const uint8_t *_buf, size_t _len);
+  is_utf8_really_inline size_t block_index();
+  is_utf8_really_inline bool has_full_block() const;
+  is_utf8_really_inline const uint8_t *full_block() const;
+  /**
+   * Get the last block, padded with spaces.
+   *
+   * There will always be a last block, with at least 1 byte, unless len == 0
+   * (in which case this function fills the buffer with spaces and returns 0. In
+   * particular, if len == STEP_SIZE there will be 0 full_blocks and 1 remainder
+   * block with STEP_SIZE bytes and no spaces for padding.
+   *
+   * @return the number of effective characters in the last block.
+   */
+  is_utf8_really_inline size_t get_remainder(uint8_t *dst) const;
+  is_utf8_really_inline void advance();
+
+private:
+  const uint8_t *buf;
+  const size_t len;
+  const size_t lenminusstep;
+  size_t idx;
+};
+
+// Routines to print masks and text for debugging bitmask operations
+is_utf8_unused static char *format_input_text_64(const uint8_t *text) {
+  static char *buf =
+      reinterpret_cast<char *>(malloc(sizeof(simd8x64<uint8_t>) + 1));
+  for (size_t i = 0; i < sizeof(simd8x64<uint8_t>); i++) {
+    buf[i] = int8_t(text[i]) < ' ' ? '_' : int8_t(text[i]);
+  }
+  buf[sizeof(simd8x64<uint8_t>)] = '\0';
+  return buf;
+}
+
+// Routines to print masks and text for debugging bitmask operations
+is_utf8_unused static char *format_input_text(const simd8x64<uint8_t> &in) {
+  static char *buf =
+      reinterpret_cast<char *>(malloc(sizeof(simd8x64<uint8_t>) + 1));
+  in.store(reinterpret_cast<uint8_t *>(buf));
+  for (size_t i = 0; i < sizeof(simd8x64<uint8_t>); i++) {
+    if (buf[i] < ' ') {
+      buf[i] = '_';
+    }
+  }
+  buf[sizeof(simd8x64<uint8_t>)] = '\0';
+  return buf;
+}
+
+is_utf8_unused static char *format_mask(uint64_t mask) {
+  static char *buf = reinterpret_cast<char *>(malloc(64 + 1));
+  for (size_t i = 0; i < 64; i++) {
+    buf[i] = (mask & (size_t(1) << i)) ? 'X' : ' ';
+  }
+  buf[64] = '\0';
+  return buf;
+}
+
+template <size_t STEP_SIZE>
+is_utf8_really_inline
+buf_block_reader<STEP_SIZE>::buf_block_reader(const uint8_t *_buf, size_t _len)
+    : buf{_buf}, len{_len},
+      lenminusstep{len < STEP_SIZE ? 0 : len - STEP_SIZE}, idx{0} {}
+
+template <size_t STEP_SIZE>
+is_utf8_really_inline size_t buf_block_reader<STEP_SIZE>::block_index() {
+  return idx;
+}
+
+template <size_t STEP_SIZE>
+is_utf8_really_inline bool buf_block_reader<STEP_SIZE>::has_full_block() const {
+  return idx < lenminusstep;
+}
+
+template <size_t STEP_SIZE>
+is_utf8_really_inline const uint8_t *
+buf_block_reader<STEP_SIZE>::full_block() const {
+  return &buf[idx];
+}
+
+template <size_t STEP_SIZE>
+is_utf8_really_inline size_t
+buf_block_reader<STEP_SIZE>::get_remainder(uint8_t *dst) const {
+  if (len == idx) {
+    return 0;
+  } // memcpy(dst, null, 0) will trigger an error with some sanitizers
+  std::memset(dst, 0x20,
+              STEP_SIZE); // std::memset STEP_SIZE because it's more efficient
+                          // to write out 8 or 16 bytes at once.
+  std::memcpy(dst, buf + idx, len - idx);
+  return len - idx;
+}
+
+template <size_t STEP_SIZE>
+is_utf8_really_inline void buf_block_reader<STEP_SIZE>::advance() {
+  idx += STEP_SIZE;
+}
+
+} // unnamed namespace
+} // namespace haswell
+} // namespace is_utf8_internals
+
+namespace is_utf8_internals {
+namespace haswell {
+namespace {
+namespace utf8_validation {
+
+using namespace simd;
+
+is_utf8_really_inline simd8<uint8_t>
+check_special_cases(const simd8<uint8_t> input, const simd8<uint8_t> prev1) {
+  // Bit 0 = Too Short (lead byte/ASCII followed by lead byte/ASCII)
+  // Bit 1 = Too Long (ASCII followed by continuation)
+  // Bit 2 = Overlong 3-byte
+  // Bit 4 = Surrogate
+  // Bit 5 = Overlong 2-byte
+  // Bit 7 = Two Continuations
+  constexpr const uint8_t TOO_SHORT = 1 << 0;  // 11______ 0_______
+                                               // 11______ 11______
+  constexpr const uint8_t TOO_LONG = 1 << 1;   // 0_______ 10______
+  constexpr const uint8_t OVERLONG_3 = 1 << 2; // 11100000 100_____
+  constexpr const uint8_t SURROGATE = 1 << 4;  // 11101101 101_____
+  constexpr const uint8_t OVERLONG_2 = 1 << 5; // 1100000_ 10______
+  constexpr const uint8_t TWO_CONTS = 1 << 7;  // 10______ 10______
+  constexpr const uint8_t TOO_LARGE = 1 << 3;  // 11110100 1001____
+                                               // 11110100 101_____
+                                               // 11110101 1001____
+                                               // 11110101 101_____
+                                               // 1111011_ 1001____
+                                               // 1111011_ 101_____
+                                               // 11111___ 1001____
+                                               // 11111___ 101_____
+  constexpr const uint8_t TOO_LARGE_1000 = 1 << 6;
+  // 11110101 1000____
+  // 1111011_ 1000____
+  // 11111___ 1000____
+  constexpr const uint8_t OVERLONG_4 = 1 << 6; // 11110000 1000____
+
+  const simd8<uint8_t> byte_1_high = prev1.shr<4>().lookup_16<uint8_t>(
+      // 0_______ ________ <ASCII in byte 1>
+      TOO_LONG, TOO_LONG, TOO_LONG, TOO_LONG, TOO_LONG, TOO_LONG, TOO_LONG,
+      TOO_LONG,
+      // 10______ ________ <continuation in byte 1>
+      TWO_CONTS, TWO_CONTS, TWO_CONTS, TWO_CONTS,
+      // 1100____ ________ <two byte lead in byte 1>
+      TOO_SHORT | OVERLONG_2,
+      // 1101____ ________ <two byte lead in byte 1>
+      TOO_SHORT,
+      // 1110____ ________ <three byte lead in byte 1>
+      TOO_SHORT | OVERLONG_3 | SURROGATE,
+      // 1111____ ________ <four+ byte lead in byte 1>
+      TOO_SHORT | TOO_LARGE | TOO_LARGE_1000 | OVERLONG_4);
+  constexpr const uint8_t CARRY =
+      TOO_SHORT | TOO_LONG | TWO_CONTS; // These all have ____ in byte 1 .
+  const simd8<uint8_t> byte_1_low =
+      (prev1 & 0x0F)
+          .lookup_16<uint8_t>(
+              // ____0000 ________
+              CARRY | OVERLONG_3 | OVERLONG_2 | OVERLONG_4,
+              // ____0001 ________
+              CARRY | OVERLONG_2,
+              // ____001_ ________
+              CARRY, CARRY,
+
+              // ____0100 ________
+              CARRY | TOO_LARGE,
+              // ____0101 ________
+              CARRY | TOO_LARGE | TOO_LARGE_1000,
+              // ____011_ ________
+              CARRY | TOO_LARGE | TOO_LARGE_1000,
+              CARRY | TOO_LARGE | TOO_LARGE_1000,
+
+              // ____1___ ________
+              CARRY | TOO_LARGE | TOO_LARGE_1000,
+              CARRY | TOO_LARGE | TOO_LARGE_1000,
+              CARRY | TOO_LARGE | TOO_LARGE_1000,
+              CARRY | TOO_LARGE | TOO_LARGE_1000,
+              CARRY | TOO_LARGE | TOO_LARGE_1000,
+              // ____1101 ________
+              CARRY | TOO_LARGE | TOO_LARGE_1000 | SURROGATE,
+              CARRY | TOO_LARGE | TOO_LARGE_1000,
+              CARRY | TOO_LARGE | TOO_LARGE_1000);
+  const simd8<uint8_t> byte_2_high = input.shr<4>().lookup_16<uint8_t>(
+      // ________ 0_______ <ASCII in byte 2>
+      TOO_SHORT, TOO_SHORT, TOO_SHORT, TOO_SHORT, TOO_SHORT, TOO_SHORT,
+      TOO_SHORT, TOO_SHORT,
+
+      // ________ 1000____
+      TOO_LONG | OVERLONG_2 | TWO_CONTS | OVERLONG_3 | TOO_LARGE_1000 |
+          OVERLONG_4,
+      // ________ 1001____
+      TOO_LONG | OVERLONG_2 | TWO_CONTS | OVERLONG_3 | TOO_LARGE,
+      // ________ 101_____
+      TOO_LONG | OVERLONG_2 | TWO_CONTS | SURROGATE | TOO_LARGE,
+      TOO_LONG | OVERLONG_2 | TWO_CONTS | SURROGATE | TOO_LARGE,
+
+      // ________ 11______
+      TOO_SHORT, TOO_SHORT, TOO_SHORT, TOO_SHORT);
+  return (byte_1_high & byte_1_low & byte_2_high);
+}
+is_utf8_really_inline simd8<uint8_t>
+check_multibyte_lengths(const simd8<uint8_t> input,
+                        const simd8<uint8_t> prev_input,
+                        const simd8<uint8_t> sc) {
+  simd8<uint8_t> prev2 = input.prev<2>(prev_input);
+  simd8<uint8_t> prev3 = input.prev<3>(prev_input);
+  simd8<uint8_t> must23 =
+      simd8<uint8_t>(must_be_2_3_continuation(prev2, prev3));
+  simd8<uint8_t> must23_80 = must23 & uint8_t(0x80);
+  return must23_80 ^ sc;
+}
+
+//
+// Return nonzero if there are incomplete multibyte characters at the end of the
+// block: e.g. if there is a 4-byte character, but it's 3 bytes from the end.
+//
+is_utf8_really_inline simd8<uint8_t> is_incomplete(const simd8<uint8_t> input) {
+  // If the previous input's last 3 bytes match this, they're too short (they
+  // ended at EOF):
+  // ... 1111____ 111_____ 11______
+  static const uint8_t max_array[32] = {255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        0b11110000u - 1,
+                                        0b11100000u - 1,
+                                        0b11000000u - 1};
+  const simd8<uint8_t> max_value(
+      &max_array[sizeof(max_array) - sizeof(simd8<uint8_t>)]);
+  return input.gt_bits(max_value);
+}
+
+struct utf8_checker {
+  // If this is nonzero, there has been a UTF-8 error.
+  simd8<uint8_t> error;
+  // The last input we received
+  simd8<uint8_t> prev_input_block;
+  // Whether the last input we received was incomplete (used for ASCII fast
+  // path)
+  simd8<uint8_t> prev_incomplete;
+
+  //
+  // Check whether the current bytes are valid UTF-8.
+  //
+  is_utf8_really_inline void check_utf8_bytes(const simd8<uint8_t> input,
+                                              const simd8<uint8_t> prev_input) {
+    // Flip prev1...prev3 so we can easily determine if they are 2+, 3+ or 4+
+    // lead bytes (2, 3, 4-byte leads become large positive numbers instead of
+    // small negative numbers)
+    simd8<uint8_t> prev1 = input.prev<1>(prev_input);
+    simd8<uint8_t> sc = check_special_cases(input, prev1);
+    this->error |= check_multibyte_lengths(input, prev_input, sc);
+  }
+
+  // The only problem that can happen at EOF is that a multibyte character is
+  // too short or a byte value too large in the last bytes: check_special_cases
+  // only checks for bytes too large in the first of two bytes.
+  is_utf8_really_inline void check_eof() {
+    // If the previous block had incomplete UTF-8 characters at the end, an
+    // ASCII block can't possibly finish them.
+    this->error |= this->prev_incomplete;
+  }
+
+  is_utf8_really_inline void check_next_input(const simd8x64<uint8_t> &input) {
+    if (is_utf8_likely(is_ascii(input))) {
+      this->error |= this->prev_incomplete;
+    } else {
+      // you might think that a for-loop would work, but under Visual Studio, it
+      // is not good enough.
+      static_assert((simd8x64<uint8_t>::NUM_CHUNKS == 2) ||
+                        (simd8x64<uint8_t>::NUM_CHUNKS == 4),
+                    "We support either two or four chunks per 64-byte block.");
+      if (simd8x64<uint8_t>::NUM_CHUNKS == 2) {
+        this->check_utf8_bytes(input.chunks[0], this->prev_input_block);
+        this->check_utf8_bytes(input.chunks[1], input.chunks[0]);
+      } else if (simd8x64<uint8_t>::NUM_CHUNKS == 4) {
+        this->check_utf8_bytes(input.chunks[0], this->prev_input_block);
+        this->check_utf8_bytes(input.chunks[1], input.chunks[0]);
+        this->check_utf8_bytes(input.chunks[2], input.chunks[1]);
+        this->check_utf8_bytes(input.chunks[3], input.chunks[2]);
+      }
+      this->prev_incomplete =
+          is_incomplete(input.chunks[simd8x64<uint8_t>::NUM_CHUNKS - 1]);
+      this->prev_input_block = input.chunks[simd8x64<uint8_t>::NUM_CHUNKS - 1];
+    }
+  }
+
+  // do not forget to call check_eof!
+  is_utf8_really_inline bool errors() const {
+    return this->error.any_bits_set_anywhere();
+  }
+
+}; // struct utf8_checker
+} // namespace utf8_validation
+
+using utf8_validation::utf8_checker;
+
+} // unnamed namespace
+} // namespace haswell
+} // namespace is_utf8_internals
+
+namespace is_utf8_internals {
+namespace haswell {
+namespace {
+namespace utf8_validation {
+
+/**
+ * Validates that the string is actual UTF-8.
+ */
+template <class checker>
+bool generic_validate_utf8(const uint8_t *input, size_t length) {
+  checker c{};
+  buf_block_reader<64> reader(input, length);
+  while (reader.has_full_block()) {
+    simd::simd8x64<uint8_t> in(reader.full_block());
+    c.check_next_input(in);
+    reader.advance();
+  }
+  uint8_t block[64]{};
+  reader.get_remainder(block);
+  simd::simd8x64<uint8_t> in(block);
+  c.check_next_input(in);
+  reader.advance();
+  c.check_eof();
+  return !c.errors();
+}
+
+bool generic_validate_utf8(const char *input, size_t length) {
+  return generic_validate_utf8<utf8_checker>(
+      reinterpret_cast<const uint8_t *>(input), length);
+}
+
+} // namespace utf8_validation
+} // unnamed namespace
+} // namespace haswell
+} // namespace is_utf8_internals
+
+namespace is_utf8_internals {
+namespace haswell {
+
+is_utf8_warn_unused bool
+implementation::validate_utf8(const char *buf, size_t len) const noexcept {
+  return haswell::utf8_validation::generic_validate_utf8(buf, len);
+}
+
+} // namespace haswell
+} // namespace is_utf8_internals
+
+IS_UTF8_UNTARGET_REGION
+
+#if IS_UTF8_GCC11ORMORE // workaround for
+                        // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=105593
+#pragma GCC diagnostic pop
+#endif // end of workaround
+
+#endif
+#if IS_UTF8_IMPLEMENTATION_PPC64
+
+// redefining IS_UTF8_IMPLEMENTATION to "ppc64"
+// #define IS_UTF8_IMPLEMENTATION ppc64
+
+namespace is_utf8_internals {
+namespace ppc64 {
+namespace {
+#ifndef IS_UTF8_PPC64_H
+#error "ppc64.h must be included"
+#endif
+using namespace simd;
+
+is_utf8_really_inline bool is_ascii(const simd8x64<uint8_t> &input) {
+  // careful: 0x80 is not ascii.
+  return input.reduce_or().saturating_sub(0b01111111u).bits_not_set_anywhere();
+}
+
+is_utf8_unused is_utf8_really_inline simd8<bool>
+must_be_continuation(const simd8<uint8_t> prev1, const simd8<uint8_t> prev2,
+                     const simd8<uint8_t> prev3) {
+  simd8<uint8_t> is_second_byte =
+      prev1.saturating_sub(0b11000000u - 1); // Only 11______ will be > 0
+  simd8<uint8_t> is_third_byte =
+      prev2.saturating_sub(0b11100000u - 1); // Only 111_____ will be > 0
+  simd8<uint8_t> is_fourth_byte =
+      prev3.saturating_sub(0b11110000u - 1); // Only 1111____ will be > 0
+  // Caller requires a bool (all 1's). All values resulting from the subtraction
+  // will be <= 64, so signed comparison is fine.
+  return simd8<int8_t>(is_second_byte | is_third_byte | is_fourth_byte) >
+         int8_t(0);
+}
+
+is_utf8_really_inline simd8<bool>
+must_be_2_3_continuation(const simd8<uint8_t> prev2,
+                         const simd8<uint8_t> prev3) {
+  simd8<uint8_t> is_third_byte =
+      prev2.saturating_sub(0b11100000u - 1); // Only 111_____ will be > 0
+  simd8<uint8_t> is_fourth_byte =
+      prev3.saturating_sub(0b11110000u - 1); // Only 1111____ will be > 0
+  // Caller requires a bool (all 1's). All values resulting from the subtraction
+  // will be <= 64, so signed comparison is fine.
+  return simd8<int8_t>(is_third_byte | is_fourth_byte) > int8_t(0);
+}
+
+} // unnamed namespace
+} // namespace ppc64
+} // namespace is_utf8_internals
+
+namespace is_utf8_internals {
+namespace ppc64 {
+namespace {
+
+// Walks through a buffer in block-sized increments, loading the last part with
+// spaces
+template <size_t STEP_SIZE> struct buf_block_reader {
+public:
+  is_utf8_really_inline buf_block_reader(const uint8_t *_buf, size_t _len);
+  is_utf8_really_inline size_t block_index();
+  is_utf8_really_inline bool has_full_block() const;
+  is_utf8_really_inline const uint8_t *full_block() const;
+  /**
+   * Get the last block, padded with spaces.
+   *
+   * There will always be a last block, with at least 1 byte, unless len == 0
+   * (in which case this function fills the buffer with spaces and returns 0. In
+   * particular, if len == STEP_SIZE there will be 0 full_blocks and 1 remainder
+   * block with STEP_SIZE bytes and no spaces for padding.
+   *
+   * @return the number of effective characters in the last block.
+   */
+  is_utf8_really_inline size_t get_remainder(uint8_t *dst) const;
+  is_utf8_really_inline void advance();
+
+private:
+  const uint8_t *buf;
+  const size_t len;
+  const size_t lenminusstep;
+  size_t idx;
+};
+
+// Routines to print masks and text for debugging bitmask operations
+is_utf8_unused static char *format_input_text_64(const uint8_t *text) {
+  static char *buf =
+      reinterpret_cast<char *>(malloc(sizeof(simd8x64<uint8_t>) + 1));
+  for (size_t i = 0; i < sizeof(simd8x64<uint8_t>); i++) {
+    buf[i] = int8_t(text[i]) < ' ' ? '_' : int8_t(text[i]);
+  }
+  buf[sizeof(simd8x64<uint8_t>)] = '\0';
+  return buf;
+}
+
+// Routines to print masks and text for debugging bitmask operations
+is_utf8_unused static char *format_input_text(const simd8x64<uint8_t> &in) {
+  static char *buf =
+      reinterpret_cast<char *>(malloc(sizeof(simd8x64<uint8_t>) + 1));
+  in.store(reinterpret_cast<uint8_t *>(buf));
+  for (size_t i = 0; i < sizeof(simd8x64<uint8_t>); i++) {
+    if (buf[i] < ' ') {
+      buf[i] = '_';
+    }
+  }
+  buf[sizeof(simd8x64<uint8_t>)] = '\0';
+  return buf;
+}
+
+is_utf8_unused static char *format_mask(uint64_t mask) {
+  static char *buf = reinterpret_cast<char *>(malloc(64 + 1));
+  for (size_t i = 0; i < 64; i++) {
+    buf[i] = (mask & (size_t(1) << i)) ? 'X' : ' ';
+  }
+  buf[64] = '\0';
+  return buf;
+}
+
+template <size_t STEP_SIZE>
+is_utf8_really_inline
+buf_block_reader<STEP_SIZE>::buf_block_reader(const uint8_t *_buf, size_t _len)
+    : buf{_buf}, len{_len},
+      lenminusstep{len < STEP_SIZE ? 0 : len - STEP_SIZE}, idx{0} {}
+
+template <size_t STEP_SIZE>
+is_utf8_really_inline size_t buf_block_reader<STEP_SIZE>::block_index() {
+  return idx;
+}
+
+template <size_t STEP_SIZE>
+is_utf8_really_inline bool buf_block_reader<STEP_SIZE>::has_full_block() const {
+  return idx < lenminusstep;
+}
+
+template <size_t STEP_SIZE>
+is_utf8_really_inline const uint8_t *
+buf_block_reader<STEP_SIZE>::full_block() const {
+  return &buf[idx];
+}
+
+template <size_t STEP_SIZE>
+is_utf8_really_inline size_t
+buf_block_reader<STEP_SIZE>::get_remainder(uint8_t *dst) const {
+  if (len == idx) {
+    return 0;
+  } // memcpy(dst, null, 0) will trigger an error with some sanitizers
+  std::memset(dst, 0x20,
+              STEP_SIZE); // std::memset STEP_SIZE because it's more efficient
+                          // to write out 8 or 16 bytes at once.
+  std::memcpy(dst, buf + idx, len - idx);
+  return len - idx;
+}
+
+template <size_t STEP_SIZE>
+is_utf8_really_inline void buf_block_reader<STEP_SIZE>::advance() {
+  idx += STEP_SIZE;
+}
+
+} // unnamed namespace
+} // namespace ppc64
+} // namespace is_utf8_internals
+
+namespace is_utf8_internals {
+namespace ppc64 {
+namespace {
+namespace utf8_validation {
+
+using namespace simd;
+
+is_utf8_really_inline simd8<uint8_t>
+check_special_cases(const simd8<uint8_t> input, const simd8<uint8_t> prev1) {
+  // Bit 0 = Too Short (lead byte/ASCII followed by lead byte/ASCII)
+  // Bit 1 = Too Long (ASCII followed by continuation)
+  // Bit 2 = Overlong 3-byte
+  // Bit 4 = Surrogate
+  // Bit 5 = Overlong 2-byte
+  // Bit 7 = Two Continuations
+  constexpr const uint8_t TOO_SHORT = 1 << 0;  // 11______ 0_______
+                                               // 11______ 11______
+  constexpr const uint8_t TOO_LONG = 1 << 1;   // 0_______ 10______
+  constexpr const uint8_t OVERLONG_3 = 1 << 2; // 11100000 100_____
+  constexpr const uint8_t SURROGATE = 1 << 4;  // 11101101 101_____
+  constexpr const uint8_t OVERLONG_2 = 1 << 5; // 1100000_ 10______
+  constexpr const uint8_t TWO_CONTS = 1 << 7;  // 10______ 10______
+  constexpr const uint8_t TOO_LARGE = 1 << 3;  // 11110100 1001____
+                                               // 11110100 101_____
+                                               // 11110101 1001____
+                                               // 11110101 101_____
+                                               // 1111011_ 1001____
+                                               // 1111011_ 101_____
+                                               // 11111___ 1001____
+                                               // 11111___ 101_____
+  constexpr const uint8_t TOO_LARGE_1000 = 1 << 6;
+  // 11110101 1000____
+  // 1111011_ 1000____
+  // 11111___ 1000____
+  constexpr const uint8_t OVERLONG_4 = 1 << 6; // 11110000 1000____
+
+  const simd8<uint8_t> byte_1_high = prev1.shr<4>().lookup_16<uint8_t>(
+      // 0_______ ________ <ASCII in byte 1>
+      TOO_LONG, TOO_LONG, TOO_LONG, TOO_LONG, TOO_LONG, TOO_LONG, TOO_LONG,
+      TOO_LONG,
+      // 10______ ________ <continuation in byte 1>
+      TWO_CONTS, TWO_CONTS, TWO_CONTS, TWO_CONTS,
+      // 1100____ ________ <two byte lead in byte 1>
+      TOO_SHORT | OVERLONG_2,
+      // 1101____ ________ <two byte lead in byte 1>
+      TOO_SHORT,
+      // 1110____ ________ <three byte lead in byte 1>
+      TOO_SHORT | OVERLONG_3 | SURROGATE,
+      // 1111____ ________ <four+ byte lead in byte 1>
+      TOO_SHORT | TOO_LARGE | TOO_LARGE_1000 | OVERLONG_4);
+  constexpr const uint8_t CARRY =
+      TOO_SHORT | TOO_LONG | TWO_CONTS; // These all have ____ in byte 1 .
+  const simd8<uint8_t> byte_1_low =
+      (prev1 & 0x0F)
+          .lookup_16<uint8_t>(
+              // ____0000 ________
+              CARRY | OVERLONG_3 | OVERLONG_2 | OVERLONG_4,
+              // ____0001 ________
+              CARRY | OVERLONG_2,
+              // ____001_ ________
+              CARRY, CARRY,
+
+              // ____0100 ________
+              CARRY | TOO_LARGE,
+              // ____0101 ________
+              CARRY | TOO_LARGE | TOO_LARGE_1000,
+              // ____011_ ________
+              CARRY | TOO_LARGE | TOO_LARGE_1000,
+              CARRY | TOO_LARGE | TOO_LARGE_1000,
+
+              // ____1___ ________
+              CARRY | TOO_LARGE | TOO_LARGE_1000,
+              CARRY | TOO_LARGE | TOO_LARGE_1000,
+              CARRY | TOO_LARGE | TOO_LARGE_1000,
+              CARRY | TOO_LARGE | TOO_LARGE_1000,
+              CARRY | TOO_LARGE | TOO_LARGE_1000,
+              // ____1101 ________
+              CARRY | TOO_LARGE | TOO_LARGE_1000 | SURROGATE,
+              CARRY | TOO_LARGE | TOO_LARGE_1000,
+              CARRY | TOO_LARGE | TOO_LARGE_1000);
+  const simd8<uint8_t> byte_2_high = input.shr<4>().lookup_16<uint8_t>(
+      // ________ 0_______ <ASCII in byte 2>
+      TOO_SHORT, TOO_SHORT, TOO_SHORT, TOO_SHORT, TOO_SHORT, TOO_SHORT,
+      TOO_SHORT, TOO_SHORT,
+
+      // ________ 1000____
+      TOO_LONG | OVERLONG_2 | TWO_CONTS | OVERLONG_3 | TOO_LARGE_1000 |
+          OVERLONG_4,
+      // ________ 1001____
+      TOO_LONG | OVERLONG_2 | TWO_CONTS | OVERLONG_3 | TOO_LARGE,
+      // ________ 101_____
+      TOO_LONG | OVERLONG_2 | TWO_CONTS | SURROGATE | TOO_LARGE,
+      TOO_LONG | OVERLONG_2 | TWO_CONTS | SURROGATE | TOO_LARGE,
+
+      // ________ 11______
+      TOO_SHORT, TOO_SHORT, TOO_SHORT, TOO_SHORT);
+  return (byte_1_high & byte_1_low & byte_2_high);
+}
+is_utf8_really_inline simd8<uint8_t>
+check_multibyte_lengths(const simd8<uint8_t> input,
+                        const simd8<uint8_t> prev_input,
+                        const simd8<uint8_t> sc) {
+  simd8<uint8_t> prev2 = input.prev<2>(prev_input);
+  simd8<uint8_t> prev3 = input.prev<3>(prev_input);
+  simd8<uint8_t> must23 =
+      simd8<uint8_t>(must_be_2_3_continuation(prev2, prev3));
+  simd8<uint8_t> must23_80 = must23 & uint8_t(0x80);
+  return must23_80 ^ sc;
+}
+
+//
+// Return nonzero if there are incomplete multibyte characters at the end of the
+// block: e.g. if there is a 4-byte character, but it's 3 bytes from the end.
+//
+is_utf8_really_inline simd8<uint8_t> is_incomplete(const simd8<uint8_t> input) {
+  // If the previous input's last 3 bytes match this, they're too short (they
+  // ended at EOF):
+  // ... 1111____ 111_____ 11______
+  static const uint8_t max_array[32] = {255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        0b11110000u - 1,
+                                        0b11100000u - 1,
+                                        0b11000000u - 1};
+  const simd8<uint8_t> max_value(
+      &max_array[sizeof(max_array) - sizeof(simd8<uint8_t>)]);
+  return input.gt_bits(max_value);
+}
+
+struct utf8_checker {
+  // If this is nonzero, there has been a UTF-8 error.
+  simd8<uint8_t> error;
+  // The last input we received
+  simd8<uint8_t> prev_input_block;
+  // Whether the last input we received was incomplete (used for ASCII fast
+  // path)
+  simd8<uint8_t> prev_incomplete;
+
+  //
+  // Check whether the current bytes are valid UTF-8.
+  //
+  is_utf8_really_inline void check_utf8_bytes(const simd8<uint8_t> input,
+                                              const simd8<uint8_t> prev_input) {
+    // Flip prev1...prev3 so we can easily determine if they are 2+, 3+ or 4+
+    // lead bytes (2, 3, 4-byte leads become large positive numbers instead of
+    // small negative numbers)
+    simd8<uint8_t> prev1 = input.prev<1>(prev_input);
+    simd8<uint8_t> sc = check_special_cases(input, prev1);
+    this->error |= check_multibyte_lengths(input, prev_input, sc);
+  }
+
+  // The only problem that can happen at EOF is that a multibyte character is
+  // too short or a byte value too large in the last bytes: check_special_cases
+  // only checks for bytes too large in the first of two bytes.
+  is_utf8_really_inline void check_eof() {
+    // If the previous block had incomplete UTF-8 characters at the end, an
+    // ASCII block can't possibly finish them.
+    this->error |= this->prev_incomplete;
+  }
+
+  is_utf8_really_inline void check_next_input(const simd8x64<uint8_t> &input) {
+    if (is_utf8_likely(is_ascii(input))) {
+      this->error |= this->prev_incomplete;
+    } else {
+      // you might think that a for-loop would work, but under Visual Studio, it
+      // is not good enough.
+      static_assert((simd8x64<uint8_t>::NUM_CHUNKS == 2) ||
+                        (simd8x64<uint8_t>::NUM_CHUNKS == 4),
+                    "We support either two or four chunks per 64-byte block.");
+      if (simd8x64<uint8_t>::NUM_CHUNKS == 2) {
+        this->check_utf8_bytes(input.chunks[0], this->prev_input_block);
+        this->check_utf8_bytes(input.chunks[1], input.chunks[0]);
+      } else if (simd8x64<uint8_t>::NUM_CHUNKS == 4) {
+        this->check_utf8_bytes(input.chunks[0], this->prev_input_block);
+        this->check_utf8_bytes(input.chunks[1], input.chunks[0]);
+        this->check_utf8_bytes(input.chunks[2], input.chunks[1]);
+        this->check_utf8_bytes(input.chunks[3], input.chunks[2]);
+      }
+      this->prev_incomplete =
+          is_incomplete(input.chunks[simd8x64<uint8_t>::NUM_CHUNKS - 1]);
+      this->prev_input_block = input.chunks[simd8x64<uint8_t>::NUM_CHUNKS - 1];
+    }
+  }
+
+  // do not forget to call check_eof!
+  is_utf8_really_inline bool errors() const {
+    return this->error.any_bits_set_anywhere();
+  }
+
+}; // struct utf8_checker
+} // namespace utf8_validation
+
+using utf8_validation::utf8_checker;
+
+} // unnamed namespace
+} // namespace ppc64
+} // namespace is_utf8_internals
+
+namespace is_utf8_internals {
+namespace ppc64 {
+namespace {
+namespace utf8_validation {
+
+/**
+ * Validates that the string is actual UTF-8.
+ */
+template <class checker>
+bool generic_validate_utf8(const uint8_t *input, size_t length) {
+  checker c{};
+  buf_block_reader<64> reader(input, length);
+  while (reader.has_full_block()) {
+    simd::simd8x64<uint8_t> in(reader.full_block());
+    c.check_next_input(in);
+    reader.advance();
+  }
+  uint8_t block[64]{};
+  reader.get_remainder(block);
+  simd::simd8x64<uint8_t> in(block);
+  c.check_next_input(in);
+  reader.advance();
+  c.check_eof();
+  return !c.errors();
+}
+
+bool generic_validate_utf8(const char *input, size_t length) {
+  return generic_validate_utf8<utf8_checker>(
+      reinterpret_cast<const uint8_t *>(input), length);
+}
+
+} // namespace utf8_validation
+} // unnamed namespace
+} // namespace ppc64
+} // namespace is_utf8_internals
+
+//
+// Implementation-specific overrides
+//
+namespace is_utf8_internals {
+namespace ppc64 {
+
+is_utf8_warn_unused bool
+implementation::validate_utf8(const char *buf, size_t len) const noexcept {
+  return ppc64::utf8_validation::generic_validate_utf8(buf, len);
+}
+
+} // namespace ppc64
+} // namespace is_utf8_internals
+
+#endif
+#if IS_UTF8_IMPLEMENTATION_WESTMERE
+
+// redefining IS_UTF8_IMPLEMENTATION to "westmere"
+// #define IS_UTF8_IMPLEMENTATION westmere
+IS_UTF8_TARGET_WESTMERE
+
+namespace is_utf8_internals {
+namespace westmere {
+namespace {
+#ifndef IS_UTF8_WESTMERE_H
+#error "westmere.h must be included"
+#endif
+using namespace simd;
+
+is_utf8_really_inline bool is_ascii(const simd8x64<uint8_t> &input) {
+  return input.reduce_or().is_ascii();
+}
+
+is_utf8_unused is_utf8_really_inline simd8<bool>
+must_be_continuation(const simd8<uint8_t> prev1, const simd8<uint8_t> prev2,
+                     const simd8<uint8_t> prev3) {
+  simd8<uint8_t> is_second_byte =
+      prev1.saturating_sub(0b11000000u - 1); // Only 11______ will be > 0
+  simd8<uint8_t> is_third_byte =
+      prev2.saturating_sub(0b11100000u - 1); // Only 111_____ will be > 0
+  simd8<uint8_t> is_fourth_byte =
+      prev3.saturating_sub(0b11110000u - 1); // Only 1111____ will be > 0
+  // Caller requires a bool (all 1's). All values resulting from the subtraction
+  // will be <= 64, so signed comparison is fine.
+  return simd8<int8_t>(is_second_byte | is_third_byte | is_fourth_byte) >
+         int8_t(0);
+}
+
+is_utf8_really_inline simd8<bool>
+must_be_2_3_continuation(const simd8<uint8_t> prev2,
+                         const simd8<uint8_t> prev3) {
+  simd8<uint8_t> is_third_byte =
+      prev2.saturating_sub(0b11100000u - 1); // Only 111_____ will be > 0
+  simd8<uint8_t> is_fourth_byte =
+      prev3.saturating_sub(0b11110000u - 1); // Only 1111____ will be > 0
+  // Caller requires a bool (all 1's). All values resulting from the subtraction
+  // will be <= 64, so signed comparison is fine.
+  return simd8<int8_t>(is_third_byte | is_fourth_byte) > int8_t(0);
+}
+
+} // unnamed namespace
+} // namespace westmere
+} // namespace is_utf8_internals
+
+namespace is_utf8_internals {
+namespace westmere {
+namespace {
+
+// Walks through a buffer in block-sized increments, loading the last part with
+// spaces
+template <size_t STEP_SIZE> struct buf_block_reader {
+public:
+  is_utf8_really_inline buf_block_reader(const uint8_t *_buf, size_t _len);
+  is_utf8_really_inline size_t block_index();
+  is_utf8_really_inline bool has_full_block() const;
+  is_utf8_really_inline const uint8_t *full_block() const;
+  /**
+   * Get the last block, padded with spaces.
+   *
+   * There will always be a last block, with at least 1 byte, unless len == 0
+   * (in which case this function fills the buffer with spaces and returns 0. In
+   * particular, if len == STEP_SIZE there will be 0 full_blocks and 1 remainder
+   * block with STEP_SIZE bytes and no spaces for padding.
+   *
+   * @return the number of effective characters in the last block.
+   */
+  is_utf8_really_inline size_t get_remainder(uint8_t *dst) const;
+  is_utf8_really_inline void advance();
+
+private:
+  const uint8_t *buf;
+  const size_t len;
+  const size_t lenminusstep;
+  size_t idx;
+};
+
+// Routines to print masks and text for debugging bitmask operations
+is_utf8_unused static char *format_input_text_64(const uint8_t *text) {
+  static char *buf =
+      reinterpret_cast<char *>(malloc(sizeof(simd8x64<uint8_t>) + 1));
+  for (size_t i = 0; i < sizeof(simd8x64<uint8_t>); i++) {
+    buf[i] = int8_t(text[i]) < ' ' ? '_' : int8_t(text[i]);
+  }
+  buf[sizeof(simd8x64<uint8_t>)] = '\0';
+  return buf;
+}
+
+// Routines to print masks and text for debugging bitmask operations
+is_utf8_unused static char *format_input_text(const simd8x64<uint8_t> &in) {
+  static char *buf =
+      reinterpret_cast<char *>(malloc(sizeof(simd8x64<uint8_t>) + 1));
+  in.store(reinterpret_cast<uint8_t *>(buf));
+  for (size_t i = 0; i < sizeof(simd8x64<uint8_t>); i++) {
+    if (buf[i] < ' ') {
+      buf[i] = '_';
+    }
+  }
+  buf[sizeof(simd8x64<uint8_t>)] = '\0';
+  return buf;
+}
+
+is_utf8_unused static char *format_mask(uint64_t mask) {
+  static char *buf = reinterpret_cast<char *>(malloc(64 + 1));
+  for (size_t i = 0; i < 64; i++) {
+    buf[i] = (mask & (size_t(1) << i)) ? 'X' : ' ';
+  }
+  buf[64] = '\0';
+  return buf;
+}
+
+template <size_t STEP_SIZE>
+is_utf8_really_inline
+buf_block_reader<STEP_SIZE>::buf_block_reader(const uint8_t *_buf, size_t _len)
+    : buf{_buf}, len{_len},
+      lenminusstep{len < STEP_SIZE ? 0 : len - STEP_SIZE}, idx{0} {}
+
+template <size_t STEP_SIZE>
+is_utf8_really_inline size_t buf_block_reader<STEP_SIZE>::block_index() {
+  return idx;
+}
+
+template <size_t STEP_SIZE>
+is_utf8_really_inline bool buf_block_reader<STEP_SIZE>::has_full_block() const {
+  return idx < lenminusstep;
+}
+
+template <size_t STEP_SIZE>
+is_utf8_really_inline const uint8_t *
+buf_block_reader<STEP_SIZE>::full_block() const {
+  return &buf[idx];
+}
+
+template <size_t STEP_SIZE>
+is_utf8_really_inline size_t
+buf_block_reader<STEP_SIZE>::get_remainder(uint8_t *dst) const {
+  if (len == idx) {
+    return 0;
+  } // memcpy(dst, null, 0) will trigger an error with some sanitizers
+  std::memset(dst, 0x20,
+              STEP_SIZE); // std::memset STEP_SIZE because it's more efficient
+                          // to write out 8 or 16 bytes at once.
+  std::memcpy(dst, buf + idx, len - idx);
+  return len - idx;
+}
+
+template <size_t STEP_SIZE>
+is_utf8_really_inline void buf_block_reader<STEP_SIZE>::advance() {
+  idx += STEP_SIZE;
+}
+
+} // unnamed namespace
+} // namespace westmere
+} // namespace is_utf8_internals
+
+namespace is_utf8_internals {
+namespace westmere {
+namespace {
+namespace utf8_validation {
+
+using namespace simd;
+
+is_utf8_really_inline simd8<uint8_t>
+check_special_cases(const simd8<uint8_t> input, const simd8<uint8_t> prev1) {
+  // Bit 0 = Too Short (lead byte/ASCII followed by lead byte/ASCII)
+  // Bit 1 = Too Long (ASCII followed by continuation)
+  // Bit 2 = Overlong 3-byte
+  // Bit 4 = Surrogate
+  // Bit 5 = Overlong 2-byte
+  // Bit 7 = Two Continuations
+  constexpr const uint8_t TOO_SHORT = 1 << 0;  // 11______ 0_______
+                                               // 11______ 11______
+  constexpr const uint8_t TOO_LONG = 1 << 1;   // 0_______ 10______
+  constexpr const uint8_t OVERLONG_3 = 1 << 2; // 11100000 100_____
+  constexpr const uint8_t SURROGATE = 1 << 4;  // 11101101 101_____
+  constexpr const uint8_t OVERLONG_2 = 1 << 5; // 1100000_ 10______
+  constexpr const uint8_t TWO_CONTS = 1 << 7;  // 10______ 10______
+  constexpr const uint8_t TOO_LARGE = 1 << 3;  // 11110100 1001____
+                                               // 11110100 101_____
+                                               // 11110101 1001____
+                                               // 11110101 101_____
+                                               // 1111011_ 1001____
+                                               // 1111011_ 101_____
+                                               // 11111___ 1001____
+                                               // 11111___ 101_____
+  constexpr const uint8_t TOO_LARGE_1000 = 1 << 6;
+  // 11110101 1000____
+  // 1111011_ 1000____
+  // 11111___ 1000____
+  constexpr const uint8_t OVERLONG_4 = 1 << 6; // 11110000 1000____
+
+  const simd8<uint8_t> byte_1_high = prev1.shr<4>().lookup_16<uint8_t>(
+      // 0_______ ________ <ASCII in byte 1>
+      TOO_LONG, TOO_LONG, TOO_LONG, TOO_LONG, TOO_LONG, TOO_LONG, TOO_LONG,
+      TOO_LONG,
+      // 10______ ________ <continuation in byte 1>
+      TWO_CONTS, TWO_CONTS, TWO_CONTS, TWO_CONTS,
+      // 1100____ ________ <two byte lead in byte 1>
+      TOO_SHORT | OVERLONG_2,
+      // 1101____ ________ <two byte lead in byte 1>
+      TOO_SHORT,
+      // 1110____ ________ <three byte lead in byte 1>
+      TOO_SHORT | OVERLONG_3 | SURROGATE,
+      // 1111____ ________ <four+ byte lead in byte 1>
+      TOO_SHORT | TOO_LARGE | TOO_LARGE_1000 | OVERLONG_4);
+  constexpr const uint8_t CARRY =
+      TOO_SHORT | TOO_LONG | TWO_CONTS; // These all have ____ in byte 1 .
+  const simd8<uint8_t> byte_1_low =
+      (prev1 & 0x0F)
+          .lookup_16<uint8_t>(
+              // ____0000 ________
+              CARRY | OVERLONG_3 | OVERLONG_2 | OVERLONG_4,
+              // ____0001 ________
+              CARRY | OVERLONG_2,
+              // ____001_ ________
+              CARRY, CARRY,
+
+              // ____0100 ________
+              CARRY | TOO_LARGE,
+              // ____0101 ________
+              CARRY | TOO_LARGE | TOO_LARGE_1000,
+              // ____011_ ________
+              CARRY | TOO_LARGE | TOO_LARGE_1000,
+              CARRY | TOO_LARGE | TOO_LARGE_1000,
+
+              // ____1___ ________
+              CARRY | TOO_LARGE | TOO_LARGE_1000,
+              CARRY | TOO_LARGE | TOO_LARGE_1000,
+              CARRY | TOO_LARGE | TOO_LARGE_1000,
+              CARRY | TOO_LARGE | TOO_LARGE_1000,
+              CARRY | TOO_LARGE | TOO_LARGE_1000,
+              // ____1101 ________
+              CARRY | TOO_LARGE | TOO_LARGE_1000 | SURROGATE,
+              CARRY | TOO_LARGE | TOO_LARGE_1000,
+              CARRY | TOO_LARGE | TOO_LARGE_1000);
+  const simd8<uint8_t> byte_2_high = input.shr<4>().lookup_16<uint8_t>(
+      // ________ 0_______ <ASCII in byte 2>
+      TOO_SHORT, TOO_SHORT, TOO_SHORT, TOO_SHORT, TOO_SHORT, TOO_SHORT,
+      TOO_SHORT, TOO_SHORT,
+
+      // ________ 1000____
+      TOO_LONG | OVERLONG_2 | TWO_CONTS | OVERLONG_3 | TOO_LARGE_1000 |
+          OVERLONG_4,
+      // ________ 1001____
+      TOO_LONG | OVERLONG_2 | TWO_CONTS | OVERLONG_3 | TOO_LARGE,
+      // ________ 101_____
+      TOO_LONG | OVERLONG_2 | TWO_CONTS | SURROGATE | TOO_LARGE,
+      TOO_LONG | OVERLONG_2 | TWO_CONTS | SURROGATE | TOO_LARGE,
+
+      // ________ 11______
+      TOO_SHORT, TOO_SHORT, TOO_SHORT, TOO_SHORT);
+  return (byte_1_high & byte_1_low & byte_2_high);
+}
+is_utf8_really_inline simd8<uint8_t>
+check_multibyte_lengths(const simd8<uint8_t> input,
+                        const simd8<uint8_t> prev_input,
+                        const simd8<uint8_t> sc) {
+  simd8<uint8_t> prev2 = input.prev<2>(prev_input);
+  simd8<uint8_t> prev3 = input.prev<3>(prev_input);
+  simd8<uint8_t> must23 =
+      simd8<uint8_t>(must_be_2_3_continuation(prev2, prev3));
+  simd8<uint8_t> must23_80 = must23 & uint8_t(0x80);
+  return must23_80 ^ sc;
+}
+
+//
+// Return nonzero if there are incomplete multibyte characters at the end of the
+// block: e.g. if there is a 4-byte character, but it's 3 bytes from the end.
+//
+is_utf8_really_inline simd8<uint8_t> is_incomplete(const simd8<uint8_t> input) {
+  // If the previous input's last 3 bytes match this, they're too short (they
+  // ended at EOF):
+  // ... 1111____ 111_____ 11______
+  static const uint8_t max_array[32] = {255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        255,
+                                        0b11110000u - 1,
+                                        0b11100000u - 1,
+                                        0b11000000u - 1};
+  const simd8<uint8_t> max_value(
+      &max_array[sizeof(max_array) - sizeof(simd8<uint8_t>)]);
+  return input.gt_bits(max_value);
+}
+
+struct utf8_checker {
+  // If this is nonzero, there has been a UTF-8 error.
+  simd8<uint8_t> error;
+  // The last input we received
+  simd8<uint8_t> prev_input_block;
+  // Whether the last input we received was incomplete (used for ASCII fast
+  // path)
+  simd8<uint8_t> prev_incomplete;
+
+  //
+  // Check whether the current bytes are valid UTF-8.
+  //
+  is_utf8_really_inline void check_utf8_bytes(const simd8<uint8_t> input,
+                                              const simd8<uint8_t> prev_input) {
+    // Flip prev1...prev3 so we can easily determine if they are 2+, 3+ or 4+
+    // lead bytes (2, 3, 4-byte leads become large positive numbers instead of
+    // small negative numbers)
+    simd8<uint8_t> prev1 = input.prev<1>(prev_input);
+    simd8<uint8_t> sc = check_special_cases(input, prev1);
+    this->error |= check_multibyte_lengths(input, prev_input, sc);
+  }
+
+  // The only problem that can happen at EOF is that a multibyte character is
+  // too short or a byte value too large in the last bytes: check_special_cases
+  // only checks for bytes too large in the first of two bytes.
+  is_utf8_really_inline void check_eof() {
+    // If the previous block had incomplete UTF-8 characters at the end, an
+    // ASCII block can't possibly finish them.
+    this->error |= this->prev_incomplete;
+  }
+
+  is_utf8_really_inline void check_next_input(const simd8x64<uint8_t> &input) {
+    if (is_utf8_likely(is_ascii(input))) {
+      this->error |= this->prev_incomplete;
+    } else {
+      // you might think that a for-loop would work, but under Visual Studio, it
+      // is not good enough.
+      static_assert((simd8x64<uint8_t>::NUM_CHUNKS == 2) ||
+                        (simd8x64<uint8_t>::NUM_CHUNKS == 4),
+                    "We support either two or four chunks per 64-byte block.");
+      if (simd8x64<uint8_t>::NUM_CHUNKS == 2) {
+        this->check_utf8_bytes(input.chunks[0], this->prev_input_block);
+        this->check_utf8_bytes(input.chunks[1], input.chunks[0]);
+      } else if (simd8x64<uint8_t>::NUM_CHUNKS == 4) {
+        this->check_utf8_bytes(input.chunks[0], this->prev_input_block);
+        this->check_utf8_bytes(input.chunks[1], input.chunks[0]);
+        this->check_utf8_bytes(input.chunks[2], input.chunks[1]);
+        this->check_utf8_bytes(input.chunks[3], input.chunks[2]);
+      }
+      this->prev_incomplete =
+          is_incomplete(input.chunks[simd8x64<uint8_t>::NUM_CHUNKS - 1]);
+      this->prev_input_block = input.chunks[simd8x64<uint8_t>::NUM_CHUNKS - 1];
+    }
+  }
+
+  // do not forget to call check_eof!
+  is_utf8_really_inline bool errors() const {
+    return this->error.any_bits_set_anywhere();
+  }
+
+}; // struct utf8_checker
+} // namespace utf8_validation
+
+using utf8_validation::utf8_checker;
+
+} // unnamed namespace
+} // namespace westmere
+} // namespace is_utf8_internals
+
+namespace is_utf8_internals {
+namespace westmere {
+namespace {
+namespace utf8_validation {
+
+/**
+ * Validates that the string is actual UTF-8.
+ */
+template <class checker>
+bool generic_validate_utf8(const uint8_t *input, size_t length) {
+  checker c{};
+  buf_block_reader<64> reader(input, length);
+  while (reader.has_full_block()) {
+    simd::simd8x64<uint8_t> in(reader.full_block());
+    c.check_next_input(in);
+    reader.advance();
+  }
+  uint8_t block[64]{};
+  reader.get_remainder(block);
+  simd::simd8x64<uint8_t> in(block);
+  c.check_next_input(in);
+  reader.advance();
+  c.check_eof();
+  return !c.errors();
+}
+
+bool generic_validate_utf8(const char *input, size_t length) {
+  return generic_validate_utf8<utf8_checker>(
+      reinterpret_cast<const uint8_t *>(input), length);
+}
+
+} // namespace utf8_validation
+} // unnamed namespace
+} // namespace westmere
+} // namespace is_utf8_internals
+//
+// Implementation-specific overrides
+//
+
+namespace is_utf8_internals {
+namespace westmere {
+
+is_utf8_warn_unused bool
+implementation::validate_utf8(const char *buf, size_t len) const noexcept {
+  return westmere::utf8_validation::generic_validate_utf8(buf, len);
+}
+
+} // namespace westmere
+} // namespace is_utf8_internals
+
+IS_UTF8_UNTARGET_REGION
+
+#endif
+
+IS_UTF8_POP_DISABLE_WARNINGS
+
+bool is_utf8(const char *src, size_t len) {
+  return is_utf8_internals::validate_utf8(src, len);
+}
diff --git a/deps/is_utf8/tests/CMakeLists.txt b/deps/is_utf8/tests/CMakeLists.txt
new file mode 100644
index 0000000..e313427
--- /dev/null
+++ b/deps/is_utf8/tests/CMakeLists.txt
@@ -0,0 +1,8 @@
+if(MSVC)
+  add_compile_options("/Zi" "/EHsc" "/GR")
+endif()
+
+include(${PROJECT_SOURCE_DIR}/cmake/add_cpp_test.cmake)
+link_libraries(is_utf8)
+
+add_cpp_test(unit)
diff --git a/deps/is_utf8/tests/unit.cpp b/deps/is_utf8/tests/unit.cpp
new file mode 100644
index 0000000..096567e
--- /dev/null
+++ b/deps/is_utf8/tests/unit.cpp
@@ -0,0 +1,338 @@
+#include "is_utf8.h"
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <iostream>
+#include <random>
+#include <vector>
+
+bool hard_coded() {
+  std::cout << "hard coded tests." << std::endl;
+  // additional tests are from autobahn websocket testsuite
+  // https://github.com/crossbario/autobahn-testsuite/tree/master/autobahntestsuite/autobahntestsuite/case
+  const char *goodsequences[] = {"a", "abcde12345", "\x71", "\x75\x4c",
+                                 "\x7f\x4c\x23\x3c\x3a\x6f\x5d\x44\x13\x70"};
+  const char *badsequences[] = {
+      "\xc3\x28",             // 0
+      "\xa0\xa1",             // 1
+      "\xe2\x28\xa1",         // 2
+      "\xe2\x82\x28",         // 3
+      "\xf0\x28\x8c\xbc",     // 4
+      "\xf0\x90\x28\xbc",     // 5
+      "\xf0\x28\x8c\x28",     // 6
+      "\xc0\x9f",             // 7
+      "\xf5\xff\xff\xff",     // 8
+      "\xed\xa0\x81",         // 9
+      "\xf8\x90\x80\x80\x80", // 10
+      "123456789012345\xed",
+      "123456789012345\xf1",
+      "123456789012345\xc2",
+      "\xC2\x7F",
+      "\xce",
+      "\xce\xba\xe1",
+      "\xce\xba\xe1\xbd",
+      "\xce\xba\xe1\xbd\xb9\xcf",
+      "\xce\xba\xe1\xbd\xb9\xcf\x83\xce",
+      "\xce\xba\xe1\xbd\xb9\xcf\x83\xce\xbc\xce",
+      "\xdf",
+      "\xef\xbf",
+      "\x80",
+      "\x91\x85\x95\x9e",
+      "\x6c\x02\x8e\x18",
+      "\x25\x5b\x6e\x2c\x32\x2c\x5b\x5b\x33\x2c\x34\x2c\x05\x29\x2c\x33\x01\x01"
+      "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"
+      "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"
+      "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"
+      "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5b"
+      "\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5d\x2c\x35\x2e\x33\x2c\x39\x2e\x33"
+      "\x2c\x37\x2e\x33\x2c\x39\x2e\x34\x2c\x37\x2e\x33\x2c\x39\x2e\x33\x2c\x37"
+      "\x2e\x33\x2c\x39\x2e\x34\x5d\x5d\x5d\x5d\x5d\x5d\x5d\x5d\x5d\x5d\x5d\x5d"
+      "\x5d\x5d\x5d\x5d\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"
+      "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x20\x01\x01"
+      "\x01\x01\x01\x02\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"
+      "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"
+      "\x01\x23\x0a\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"
+      "\x01\x01\x01\x01\x01\x01\x01\x01\x7e\x7e\x0a\x0a\x01\x01\x01\x01\x01\x01"
+      "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x5b\x5b"
+      "\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5d\x2c\x37"
+      "\x2e\x33\x2c\x39\x2e\x33\x2c\x37\x2e\x33\x2c\x39\x2e\x34\x2c\x37\x2e\x33"
+      "\x2c\x39\x2e\x33\x2c\x37\x2e\x33\x2c\x39\x2e\x34\x5d\x5d\x5d\x5d\x5d\x5d"
+      "\x5d\x5d\x5d\x5d\x5d\x5d\x5d\x5d\x5d\x01\x01\x80\x01\x01\x01\x79\x01\x01"
+      "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"
+      "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"
+      "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"
+      "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"
+      "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"
+      "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"
+      "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"
+      "\x01\x01\x01\x01\x01\x01\x01\x01\x01",
+      "[[[[[[[[[[[[[[["
+      "\x80\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"
+      "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"
+      "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"
+      "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"
+      "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"
+      "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x010\x01\x01\x01\x01\x01\x01"
+      "\x01\x01\x01\x01\x01",
+      "\x20\x0b\x01\x01\x01\x64\x3a\x64\x3a\x64\x3a\x5b\x5b\x5b\x5b\x5b\x5b\x5b"
+      "\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5b"
+      "\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x5b\x30\x01"
+      "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"
+      "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"
+      "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"
+      "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"
+      "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"
+      "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"
+      "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x80\x01\x01\x01\x01\x01\x01\x01"
+      "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"
+      "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"
+      "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"
+      "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"
+      "\x01\x01\x01\x01\x01",
+      "\x80",
+      "\x90",
+      "\xa1",
+      "\xb2",
+      "\xc3",
+      "\xd4",
+      "\xe5",
+      "\xf6"
+      "\xc3\xb1"};
+  size_t number_good = sizeof(goodsequences) / sizeof(goodsequences[0]);
+  printf("Testing %zu good sequences.\n", number_good);
+  for (size_t i = 0; i < number_good; i++) {
+    size_t len = std::strlen(goodsequences[i]);
+    if (!is_utf8(goodsequences[i], len)) {
+      printf("bug goodsequences[%zu]\n", i);
+      return false;
+    }
+  }
+  size_t number_bad = sizeof(badsequences) / sizeof(badsequences[0]);
+  printf("Testing %zu bad sequences.\n", number_bad);
+  for (size_t i = 0; i < number_bad; i++) {
+    size_t len = std::strlen(badsequences[i]);
+    if (is_utf8(badsequences[i], len)) {
+      printf("bug badsequences[%zu]\n", i);
+      return false;
+    }
+  }
+  printf("Success.\n");
+  return true;
+}
+
+class random_utf8 final {
+public:
+  random_utf8(uint32_t seed, int prob_1byte, int prob_2bytes, int prob_3bytes,
+              int prob_4bytes);
+
+  std::vector<uint8_t> generate(size_t output_bytes);
+  // include the number of code points
+  std::pair<std::vector<uint8_t>, size_t> generate_counted(size_t output_bytes);
+  std::vector<uint8_t> generate(size_t output_bytes, long seed);
+
+private:
+  uint32_t generate();
+
+  std::mt19937 gen;
+  std::discrete_distribution<> bytes_count;
+  std::uniform_int_distribution<int> val_7bit{0x00, 0x7f}; // 0b0xxxxxxx
+  std::uniform_int_distribution<int> val_6bit{0x00, 0x3f}; // 0b10xxxxxx
+  std::uniform_int_distribution<int> val_5bit{0x00, 0x1f}; // 0b110xxxxx
+  std::uniform_int_distribution<int> val_4bit{0x00, 0x0f}; // 0b1110xxxx
+  std::uniform_int_distribution<int> val_3bit{0x00, 0x07}; // 0b11110xxx
+};
+
+random_utf8::random_utf8(uint32_t seed, int prob_1byte, int prob_2bytes,
+                         int prob_3bytes, int prob_4bytes)
+    : gen(seed), bytes_count({double(prob_1byte), double(prob_2bytes),
+                              double(prob_3bytes), double(prob_4bytes)}) {}
+
+std::pair<std::vector<uint8_t>, size_t>
+random_utf8::generate_counted(size_t output_bytes) {
+  std::vector<uint8_t> result;
+  result.reserve(output_bytes);
+  uint8_t candidate, head;
+  size_t count{0};
+  while (result.size() < output_bytes) {
+    count++;
+    switch (bytes_count(gen)) {
+    case 0: // 1 byte
+      candidate = uint8_t(val_7bit(gen));
+      while (candidate == 0) { // though strictly speaking, a stream of nulls is
+                               // UTF8, it tends to break some code
+        candidate = uint8_t(val_7bit(gen));
+      }
+      result.push_back(candidate);
+      break;
+    case 1: // 2 bytes
+      candidate = 0xc0 | uint8_t(val_5bit(gen));
+      while (candidate < 0xC2) {
+        candidate = 0xc0 | uint8_t(val_5bit(gen));
+      }
+      result.push_back(candidate);
+      result.push_back(0x80 | uint8_t(val_6bit(gen)));
+      break;
+    case 2: // 3 bytes
+      head = 0xe0 | uint8_t(val_4bit(gen));
+      result.push_back(head);
+      candidate = 0x80 | uint8_t(val_6bit(gen));
+      if (head == 0xE0) {
+        while (candidate < 0xA0) {
+          candidate = 0x80 | uint8_t(val_6bit(gen));
+        }
+      } else if (head == 0xED) {
+        while (candidate > 0x9F) {
+          candidate = 0x80 | uint8_t(val_6bit(gen));
+        }
+      }
+      result.push_back(candidate);
+      result.push_back(0x80 | uint8_t(val_6bit(gen)));
+      break;
+    case 3: // 4 bytes
+      head = 0xf0 | uint8_t(val_3bit(gen));
+      while (head > 0xF4) {
+        head = 0xf0 | uint8_t(val_3bit(gen));
+      }
+      result.push_back(head);
+      candidate = 0x80 | uint8_t(val_6bit(gen));
+      if (head == 0xF0) {
+        while (candidate < 0x90) {
+          candidate = 0x80 | uint8_t(val_6bit(gen));
+        }
+      } else if (head == 0xF4) {
+        while (candidate > 0x8F) {
+          candidate = 0x80 | uint8_t(val_6bit(gen));
+        }
+      }
+      result.push_back(candidate);
+      result.push_back(0x80 | uint8_t(val_6bit(gen)));
+      result.push_back(0x80 | uint8_t(val_6bit(gen)));
+      break;
+    }
+  }
+  result.push_back(0); // EOS for scalar code
+
+  return make_pair(result, count);
+}
+
+std::vector<uint8_t> random_utf8::generate(size_t output_bytes) {
+  return generate_counted(output_bytes).first;
+}
+
+std::vector<uint8_t> random_utf8::generate(size_t output_bytes, long seed) {
+  gen.seed(uint32_t(seed));
+  return generate(output_bytes);
+}
+
+// credit: based on code from Google Fuchsia (Apache Licensed)
+bool reference_validate_utf8(const char *buf, size_t len) noexcept {
+  const uint8_t *data = (const uint8_t *)buf;
+  uint64_t pos = 0;
+  uint64_t next_pos = 0;
+  uint32_t code_point = 0;
+  while (pos < len) {
+    unsigned char byte = data[pos];
+    if (byte < 0b10000000) {
+      pos++;
+      continue;
+    } else if ((byte & 0b11100000) == 0b11000000) {
+      next_pos = pos + 2;
+      if (next_pos > len) {
+        return false;
+      }
+      if ((data[pos + 1] & 0b11000000) != 0b10000000) {
+        return false;
+      }
+      // range check
+      code_point = (byte & 0b00011111) << 6 | (data[pos + 1] & 0b00111111);
+      if (code_point < 0x80 || 0x7ff < code_point) {
+        return false;
+      }
+    } else if ((byte & 0b11110000) == 0b11100000) {
+      next_pos = pos + 3;
+      if (next_pos > len) {
+        return false;
+      }
+      if ((data[pos + 1] & 0b11000000) != 0b10000000) {
+        return false;
+      }
+      if ((data[pos + 2] & 0b11000000) != 0b10000000) {
+        return false;
+      }
+      // range check
+      code_point = (byte & 0b00001111) << 12 |
+                   (data[pos + 1] & 0b00111111) << 6 |
+                   (data[pos + 2] & 0b00111111);
+      if (code_point < 0x800 || 0xffff < code_point ||
+          (0xd7ff < code_point && code_point < 0xe000)) {
+        return false;
+      }
+    } else if ((byte & 0b11111000) == 0b11110000) { // 0b11110000
+      next_pos = pos + 4;
+      if (next_pos > len) {
+        return false;
+      }
+      if ((data[pos + 1] & 0b11000000) != 0b10000000) {
+        return false;
+      }
+      if ((data[pos + 2] & 0b11000000) != 0b10000000) {
+        return false;
+      }
+      if ((data[pos + 3] & 0b11000000) != 0b10000000) {
+        return false;
+      }
+      // range check
+      code_point =
+          (byte & 0b00000111) << 18 | (data[pos + 1] & 0b00111111) << 12 |
+          (data[pos + 2] & 0b00111111) << 6 | (data[pos + 3] & 0b00111111);
+      if (code_point < 0xffff || 0x10ffff < code_point) {
+        return false;
+      }
+    } else {
+      // we may have a continuation
+      return false;
+    }
+    pos = next_pos;
+  }
+  return true;
+}
+bool brute_force() {
+
+  std::cout << "brute force tests." << std::endl;
+  uint32_t seed{1234};
+  random_utf8 gen_1_2_3_4(seed, 1, 1, 1, 1);
+  size_t total = 10000;
+  for (size_t i = 0; i < total; i++) {
+    if ((i % 1000) == 0) {
+      printf(".");
+      fflush(NULL);
+    }
+
+    auto UTF8 = gen_1_2_3_4.generate(rand() % 1024);
+    if (!is_utf8((const char *)UTF8.data(), UTF8.size())) {
+      std::cerr << "bug" << std::endl;
+      return false;
+    }
+    for (size_t flip = 0; flip < 1000; ++flip) {
+      // we are going to hack the string as long as it is UTF-8
+      const int bitflip{1 << (rand() % 8)};
+      UTF8[rand() % UTF8.size()] = uint8_t(bitflip); // we flip exactly one bit
+      bool is_ok = is_utf8((const char *)UTF8.data(), UTF8.size());
+      bool is_ok_basic =
+          reference_validate_utf8((const char *)UTF8.data(), UTF8.size());
+      if (is_ok != is_ok_basic) {
+        std::cerr << "bug" << std::endl;
+        return false;
+      }
+    }
+  }
+  printf("\n");
+  printf("Success.\n");
+  return true;
+}
+
+int main() {
+  bool results = hard_coded() & brute_force();
+  return results ? EXIT_SUCCESS : EXIT_FAILURE;
+}
\ No newline at end of file
diff --git a/package.json b/package.json
index 444f5e7..3873323 100644
--- a/package.json
+++ b/package.json
@@ -15,6 +15,9 @@
   "files": [
     "prebuilds/",
     "src/",
+    "deps/is_utf8/LICENSE-MIT",
+    "deps/is_utf8/include/is_utf8.h",
+    "deps/is_utf8/src/is_utf8.cpp",
     "binding.gyp",
     "fallback.js",
     "index.js"
diff --git a/src/validation.c b/src/validation.c
deleted file mode 100644
index dd260b1..0000000
--- a/src/validation.c
+++ /dev/null
@@ -1,109 +0,0 @@
-#define NAPI_VERSION 1
-#include <assert.h>
-#include <string.h>
-#include <node_api.h>
-
-napi_value IsValidUTF8(napi_env env, napi_callback_info info) {
-  napi_status status;
-  size_t argc = 1;
-  napi_value argv[1];
-
-  status = napi_get_cb_info(env, info, &argc, argv, NULL, NULL);
-  assert(status == napi_ok);
-
-  uint8_t *buf;
-  size_t len;
-
-  status = napi_get_buffer_info(env, argv[0], (void **)&buf, &len);
-  assert(status == napi_ok);
-
-  size_t i = 0;
-
-  //
-  // This code has been taken from utf8_check.c which was developed by
-  // Markus Kuhn <http://www.cl.cam.ac.uk/~mgk25/>.
-  //
-  // For original code / licensing please refer to
-  // https://www.cl.cam.ac.uk/%7Emgk25/ucs/utf8_check.c
-  //
-  while (i < len) {
-    size_t j = i + 8;
-
-    if (j <= len) {
-      //
-      // Read 8 bytes and check if they are ASCII.
-      //
-      uint64_t chunk;
-      memcpy(&chunk, buf + i, 8);
-
-      if ((chunk & 0x8080808080808080) == 0x00) {
-        i = j;
-        continue;
-      }
-    }
-
-    while ((buf[i] & 0x80) == 0x00) { // 0xxxxxxx
-      if (++i == len) {
-        goto exit;
-      }
-    }
-
-    if ((buf[i] & 0xe0) == 0xc0) {  // 110xxxxx 10xxxxxx
-      if (
-        i + 1 == len ||
-        (buf[i + 1] & 0xc0) != 0x80 ||
-        (buf[i] & 0xfe) == 0xc0  // overlong
-      ) {
-        break;
-      }
-
-      i += 2;
-    } else if ((buf[i] & 0xf0) == 0xe0) {  // 1110xxxx 10xxxxxx 10xxxxxx
-      if (
-        i + 2 >= len ||
-        (buf[i + 1] & 0xc0) != 0x80 ||
-        (buf[i + 2] & 0xc0) != 0x80 ||
-        (buf[i] == 0xe0 && (buf[i + 1] & 0xe0) == 0x80) ||  // overlong
-        (buf[i] == 0xed && (buf[i + 1] & 0xe0) == 0xa0)  // surrogate (U+D800 - U+DFFF)
-      ) {
-        break;
-      }
-
-      i += 3;
-    } else if ((buf[i] & 0xf8) == 0xf0) {  // 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
-      if (
-        i + 3 >= len ||
-        (buf[i + 1] & 0xc0) != 0x80 ||
-        (buf[i + 2] & 0xc0) != 0x80 ||
-        (buf[i + 3] & 0xc0) != 0x80 ||
-        (buf[i] == 0xf0 && (buf[i + 1] & 0xf0) == 0x80) ||  // overlong
-        (buf[i] == 0xf4 && buf[i + 1] > 0x8f) || buf[i] > 0xf4  // > U+10FFFF
-      ) {
-        break;
-      }
-
-      i += 4;
-    } else {
-      break;
-    }
-  }
-
-exit:;
-  napi_value result;
-  status = napi_get_boolean(env, i == len, &result);
-  assert(status == napi_ok);
-
-  return result;
-}
-
-napi_value Init(napi_env env, napi_value exports) {
-  napi_status status;
-  napi_value isValidUTF8;
-
-  status = napi_create_function(env, NULL, 0, IsValidUTF8, NULL, &isValidUTF8);
-  assert(status == napi_ok);
-
-  return isValidUTF8;
-}
-
-NAPI_MODULE(NODE_GYP_MODULE_NAME, Init)
diff --git a/src/validation.cc b/src/validation.cc
new file mode 100644
index 0000000..871f443
--- /dev/null
+++ b/src/validation.cc
@@ -0,0 +1,40 @@
+#define NAPI_VERSION 1
+#include <assert.h>
+#include <node_api.h>
+
+#include "../deps/is_utf8/include/is_utf8.h"
+
+napi_value IsValidUTF8(napi_env env, napi_callback_info info) {
+  napi_status status;
+  size_t argc = 1;
+  napi_value argv[1];
+
+  status = napi_get_cb_info(env, info, &argc, argv, NULL, NULL);
+  assert(status == napi_ok);
+
+  char *buf;
+  size_t len;
+
+  status = napi_get_buffer_info(env, argv[0], (void **)&buf, &len);
+  assert(status == napi_ok);
+
+  bool is_valid = is_utf8(buf, len);
+
+  napi_value result;
+  status = napi_get_boolean(env, is_valid, &result);
+  assert(status == napi_ok);
+
+  return result;
+}
+
+napi_value Init(napi_env env, napi_value exports) {
+  napi_status status;
+  napi_value isValidUTF8;
+
+  status = napi_create_function(env, NULL, 0, IsValidUTF8, NULL, &isValidUTF8);
+  assert(status == napi_ok);
+
+  return isValidUTF8;
+}
+
+NAPI_MODULE(NODE_GYP_MODULE_NAME, Init)